title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
list | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
在 Linux 中如何以人性化的方式显示数据
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3296631/linux/displaying-data-in-a-human-friendly-way-on-linux.html
|
许多 Linux 命令现在都有使其输出更易于理解的选项。让我们了解一些可以让我们心爱的操作系统更友好的东西。
|
/data/attachment/album/201808/22/105748bos9lhovstcj2nz8.jpg.thumb.jpg
|
/data/attachment/album/201808/22/105748bos9lhovstcj2nz8.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"命令行",
"人性化"
] |
技术
|
{
"viewnum": 5215,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
许多 Linux 命令现在都有使其输出更易于理解的选项。让我们了解一些可以让我们心爱的操作系统更友好的东西。
| 2018-08-22T10:57:00 | 2018-08-22T10:57:00 | 9,941 |
/article-9941-1.html
|
>
> 许多 Linux 命令现在都有使其输出更易于理解的选项。让我们了解一些可以让我们心爱的操作系统更友好的东西。
>
>
>
不是每个人都以二进制方式思考，他们不想在大脑中给大数字插入逗号来了解文件的大小。因此，Linux 命令在过去的几十年里不断发展，以更人性化的方式向用户显示信息，这一点也不奇怪。在今天的文章中，我们将看一看各种命令所提供的一些选项，它们使得数据变得更容易理解。
### 为什么默认显示不更友好一些？
如果你想知道为什么默认不显示得更人性化，毕竟，我们人类才是计算机的默认用户啊。你可能会问自己：“为什么我们不竭尽全力输出对每个人都有意义的命令的响应？”主要的答案是：改变命令的默认输出可能会干扰许多其它进程，这些进程是在期望默认响应之上构建的。其它的工具，以及过去几十年开发的脚本，如果突然以一种完全不同的格式输出，而不是它们过去所期望的那样，可能会被一种非常丑陋的方式破坏。
说真的，也许我们中的一些人可能更愿意看文件大小中的所有数字，即 1338277310 而不是 1.3G。在任何情况下，切换默认习惯都可能造成破坏，但是为更加人性化的响应提供一些简单的选项只需要让我们学习一些命令选项而已。
### 可以显示人性化数据的命令
有哪些简单的选项可以使 Unix 命令的输出更容易解析呢？让我们来看一些命令。
#### top
你可能没有注意到这个命令，但是在 top 命令中，你可以通过输入 `E`（大写字母 E）来更改显示全部内存使用的方式。连续按下将数字显示从 KiB 到 MiB，再到 GiB，接着是 TiB、PiB、EiB，最后回到 KiB。
认识这些单位吧？这里有一组定义：
```
2`10 = 1,024 = 1 KiB (kibibyte)
2`20 = 1,048,576 = 1 MiB (mebibyte)
2`30 = 1,073,741,824 = 1 GiB (gibibyte)
2`40 = 1,099,511,627,776 = 1 TiB (tebibyte)
2`50 = 1,125,899,906,842,624 = PiB (pebibyte)
2`60 = 1,152,921,504,606,846,976 = EiB (exbibyte)
2`70 = 1,180,591,620,717,411,303,424 = 1 ZiB (zebibyte)
2`80 = 1,208,925,819,614,629,174,706,176 = 1 YiB (yobibyte)
```
这些单位与千字节（KB）、兆字节（MB）和千兆字节（GB）密切相关。虽然它们很接近，但是它们之间仍有很大的区别：一组是基于 10 的幂，另一组是基于 2 的幂。例如，比较千字节和千兆字节，我们可以看看它们不同点：
```
KB = 1000 = 10`3
KiB = 1024 = 2`10
```
以下是 `top` 命令输出示例，使用 KiB 为单位默认显示：
```
top - 10:49:06 up 5 days, 35 min, 1 user, load average: 0.05, 0.04, 0.01
Tasks: 158 total, 1 running, 118 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.2 sy, 0.0 ni, 99.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 6102680 total, 4634980 free, 392244 used, 1075456 buff/cache
KiB Swap: 2097148 total, 2097148 free, 0 used. 5407432 avail Mem
```
在按下 `E` 之后，单位变成了 MiB：
```
top - 10:49:31 up 5 days, 36 min, 1 user, load average: 0.03, 0.04, 0.01
Tasks: 158 total, 2 running, 118 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.6 sy, 0.0 ni, 99.4 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 5959.648 total, 4526.348 free, 383.055 used, 1050.246 buff/cache
MiB Swap: 2047.996 total, 2047.996 free, 0.000 used. 5280.684 avail Mem
```
再次按下 `E`，单位变为 GiB：
```
top - 10:49:49 up 5 days, 36 min, 1 user, load average: 0.02, 0.03, 0.01
Tasks: 158 total, 1 running, 118 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
GiB Mem : 5.820 total, 4.420 free, 0.374 used, 1.026 buff/cache
GiB Swap: 2.000 total, 2.000 free, 0.000 used. 5.157 avail Mem
```
你还可以通过按字母 `e` 来更改为显示每个进程使用内存的数字单位。它将从默认的 KiB 到 MiB，再到 GiB、TiB，接着到 PiB（估计你能看到小数点后的很多 0），然后返回 KiB。下面是按了一下 `e` 之后的 `top` 输出：
```
top - 08:45:28 up 4 days, 22:32, 1 user, load average: 0.02, 0.03, 0.00
Tasks: 167 total, 1 running, 118 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.2 us, 0.0 sy, 0.0 ni, 99.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 6102680 total, 4641836 free, 393348 used, 1067496 buff/cache
KiB Swap: 2097148 total, 2097148 free, 0 used. 5406396 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
784 root 20 0 543.2m 26.8m 16.1m S 0.9 0.5 0:22.20 snapd
733 root 20 0 107.8m 2.0m 1.8m S 0.4 0.0 0:18.49 irqbalance
22574 shs 20 0 107.5m 5.5m 4.6m S 0.4 0.1 0:00.09 sshd
1 root 20 0 156.4m 9.3m 6.7m S 0.0 0.2 0:05.59 systemd
```
#### du
`du` 命令显示磁盘空间文件或目录使用了多少，如果使用 `-h` 选项，则将输出大小调整为最合适的单位。默认情况下，它以千字节（KB）为单位。
```
$ du camper*
360 camper_10.jpg
5684 camper.jpg
240 camper_small.jpg
$ du -h camper*
360K camper_10.jpg
5.6M camper.jpg
240K camper_small.jpg
```
#### df
`df` 命令也提供了一个 `-h` 选项。请注意在下面的示例中是如何以千兆字节（GB）和兆字节（MB）输出的：
```
$ df -h | grep -v loop
Filesystem Size Used Avail Use% Mounted on
udev 2.9G 0 2.9G 0% /dev
tmpfs 596M 1.7M 595M 1% /run
/dev/sda1 110G 9.0G 95G 9% /
tmpfs 3.0G 0 3.0G 0% /dev/shm
tmpfs 5.0M 4.0K 5.0M 1% /run/lock
tmpfs 3.0G 0 3.0G 0% /sys/fs/cgroup
tmpfs 596M 16K 596M 1% /run/user/121
/dev/sdb2 457G 73M 434G 1% /apps
tmpfs 596M 0 596M 0% /run/user/1000
```
下面的命令使用了 `-h` 选项，同时使用 `-T` 选项来显示我们正在查看的文件系统的类型。
```
$ df -hT /mnt2
Filesystem Type Size Used Avail Use% Mounted on
/dev/sdb2 ext4 457G 73M 434G 1% /apps
```
#### ls
即使是 `ls`，它也为我们提供了调整大小显示的选项，保证是最合理的单位。
```
$ ls -l camper*
-rw-rw-r-- 1 shs shs 365091 Jul 14 19:42 camper_10.jpg
-rw-rw-r-- 1 shs shs 5818597 Jul 14 19:41 camper.jpg
-rw-rw-r-- 1 shs shs 241844 Jul 14 19:45 camper_small.jpg
$ ls -lh camper*
-rw-rw-r-- 1 shs shs 357K Jul 14 19:42 camper_10.jpg
-rw-rw-r-- 1 shs shs 5.6M Jul 14 19:41 camper.jpg
-rw-rw-r-- 1 shs shs 237K Jul 14 19:45 camper_small.jpg
```
#### free
`free` 命令允许你以字节（B），千字节（KB），兆字节（MB）和千兆字节（GB）为单位查看内存使用情况。
```
$ free -b
total used free shared buff/cache available
Mem: 6249144320 393076736 4851625984 1654784 1004441600 5561253888
Swap: 2147479552 0 2147479552
$ free -k
total used free shared buff/cache available
Mem: 6102680 383836 4737924 1616 980920 5430932
Swap: 2097148 0 2097148
$ free -m
total used free shared buff/cache available
Mem: 5959 374 4627 1 957 5303
Swap: 2047 0 2047
$ free -g
total used free shared buff/cache available
Mem: 5 0 4 0 0 5
Swap: 1 0 1
```
#### tree
虽然 `tree` 命令与文件或内存计算无关，但它也提供了非常人性化的文件视图，它分层显示文件以说明文件是如何组织的。当你试图了解如何安排目录内容时，这种显示方式非常有用。（LCTT 译注：也可以看看 `pstree`，它以树状结构显示进程树。）
```
$ tree
.g to
├── 123
├── appended.png
├── appts
├── arrow.jpg
├── arrow.png
├── bin
│ ├── append
│ ├── cpuhog1
│ ├── cpuhog2
│ ├── loop
│ ├── mkhome
│ ├── runme
```
#### stat
`stat` 命令是另一个以非常人性化的格式显示信息的命令。它提供了更多关于文件的元数据，包括文件大小（以字节和块为单位）、文件类型、设备和 inode（索引节点）、文件所有者和组（名称和数字 ID）、以数字和 rwx 格式显示的文件权限以及文件的最后访问和修改日期。在某些情况下，它也可能显示最初创建文件的时间。
```
$ stat camper*
File: camper_10.jpg
Size: 365091 Blocks: 720 IO Block: 4096 regular file
Device: 801h/2049d Inode: 796059 Links: 1
Access: (0664/-rw-rw-r--) Uid: ( 1000/ shs) Gid: ( 1000/ shs)
Access: 2018-07-19 18:56:31.841013385 -0400
Modify: 2018-07-14 19:42:25.230519509 -0400
Change: 2018-07-14 19:42:25.230519509 -0400
Birth: -
File: camper.jpg
Size: 5818597 Blocks: 11368 IO Block: 4096 regular file
Device: 801h/2049d Inode: 796058 Links: 1
Access: (0664/-rw-rw-r--) Uid: ( 1000/ shs) Gid: ( 1000/ shs)
Access: 2018-07-19 18:56:31.845013872 -0400
Modify: 2018-07-14 19:41:46.882024039 -0400
Change: 2018-07-14 19:41:46.882024039 -0400
Birth: -
```
### 总结
Linux 命令提供了许多选项，可以让用户更容易理解或比较它们的输出。对于许多命令，`-h` 选项会显示更友好的输出格式。对于其它的，你可能必须通过使用某些特定选项或者按下某个键来查看你希望的输出。我希望这其中一些选项会让你的 Linux 系统看起来更友好一点。
---
via: <https://www.networkworld.com/article/3296631/linux/displaying-data-in-a-human-friendly-way-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Ptrace 去拦截和仿真 Linux 系统调用
|
Chris Wellons
|
http://nullprogram.com/blog/2018/06/23/
|
ptrace(2)（“进程跟踪”）系统调用通常都与调试有关。它是类 Unix 系统上通过原生调试器监测被调试进程的主要机制。它也是实现 strace（系统调用跟踪）的常见方法。
|
/data/attachment/album/201808/22/133757z7896qpkfrdfg25z.jpg.thumb.jpg
|
/data/attachment/album/201808/22/133757z7896qpkfrdfg25z.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"调试",
"跟踪",
"Ptrace"
] |
技术
|
{
"viewnum": 12019,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
ptrace(2)（“进程跟踪”）系统调用通常都与调试有关。它是类 Unix 系统上通过原生调试器监测被调试进程的主要机制。它也是实现 strace（系统调用跟踪）的常见方法。
| 2018-08-22T13:38:00 | 2018-08-22T13:38:00 | 9,942 |
/article-9942-1.html
|
`ptrace(2)`（“<ruby> 进程跟踪 <rt> process trace </rt></ruby>”）系统调用通常都与调试有关。它是类 Unix 系统上通过原生调试器监测被调试进程的主要机制。它也是实现 [strace](https://blog.plover.com/Unix/strace-groff.html)（<ruby> 系统调用跟踪 <rt> system call trace </rt></ruby>）的常见方法。使用 Ptrace，跟踪器可以暂停被跟踪进程，[检查和设置寄存器和内存](http://nullprogram.com/blog/2016/09/03/)，监视系统调用，甚至可以<ruby> 拦截 <rp> （ </rp> <rt> intercepting </rt> <rp> ） </rp></ruby>系统调用。
通过拦截功能，意味着跟踪器可以篡改系统调用参数，篡改系统调用的返回值，甚至阻塞某些系统调用。言外之意就是，一个跟踪器本身完全可以提供系统调用服务。这是件非常有趣的事，因为这意味着**一个跟踪器可以仿真一个完整的外部操作系统**，而这些都是在没有得到内核任何帮助的情况下由 Ptrace 实现的。
问题是，在同一时间一个进程只能被一个跟踪器附着，因此在那个进程的调试期间，不可能再使用诸如 GDB 这样的工具去仿真一个外部操作系统。另外的问题是，仿真系统调用的开销非常高。
在本文中，我们将专注于 x86-64 [Linux 的 Ptrace](http://man7.org/linux/man-pages/man2/ptrace.2.html)，并将使用一些 Linux 专用的扩展。同时，在本文中，我们将忽略掉一些错误检查，但是完整的源代码仍然会包含这些错误检查。
本文中的可直接运行的示例代码在这里：<https://github.com/skeeto/ptrace-examples>
### strace
在进入到最有趣的部分之前，我们先从回顾 strace 的基本实现来开始。它[不是 DTrace](http://nullprogram.com/blog/2018/01/17/)，但 strace 仍然非常有用。
Ptrace 一直没有被标准化。它的接口在不同的操作系统上非常类似，尤其是在核心功能方面，但是在不同的系统之间仍然存在细微的差别。`ptrace(2)` 的原型基本上应该像下面这样，但特定的类型可能有些差别。
```
long ptrace(int request, pid_t pid, void *addr, void *data);
```
`pid` 是被跟踪进程的 ID。虽然**同一个时间**只有一个跟踪器可以附着到该进程上，但是一个跟踪器可以附着跟踪多个进程。
`request` 字段选择一个具体的 Ptrace 函数，比如 `ioctl(2)` 接口。对于 strace，只需要两个：
* `PTRACE_TRACEME`：这个进程被它的父进程跟踪。
* `PTRACE_SYSCALL`：继续跟踪，但是在下一下系统调用入口或出口时停止。
* `PTRACE_GETREGS`：取得被跟踪进程的寄存器内容副本。
另外两个字段，`addr` 和 `data`，作为所选的 Ptrace 函数的一般参数。一般情况下，可以忽略一个或全部忽略，在那种情况下，传递零个参数。
strace 接口实质上是前缀到另一个命令之前。
```
$ strace [strace options] program [arguments]
```
最小化的 strace 不需要任何选项，因此需要做的第一件事情是 —— 假设它至少有一个参数 —— 在 `argv` 尾部的 `fork(2)` 和 `exec(2)` 被跟踪进程。但是在加载目标程序之前，新的进程将告知内核，目标程序将被它的父进程继续跟踪。被跟踪进程将被这个 Ptrace 系统调用暂停。
```
pid_t pid = fork();
switch (pid) {
case -1: /* error */
FATAL("%s", strerror(errno));
case 0: /* child */
ptrace(PTRACE_TRACEME, 0, 0, 0);
execvp(argv[1], argv + 1);
FATAL("%s", strerror(errno));
}
```
父进程使用 `wait(2)` 等待子进程的 `PTRACE_TRACEME`，当 `wait(2)` 返回后，子进程将被暂停。
```
waitpid(pid, 0, 0);
```
在允许子进程继续运行之前，我们告诉操作系统，被跟踪进程和它的父进程应该一同被终止。一个真实的 strace 实现可能会设置其它的选择，比如： `PTRACE_O_TRACEFORK`。
```
ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_EXITKILL);
```
剩余部分就是一个简单的、无休止的循环了，每循环一次捕获一个系统调用。循环体总共有四步：
1. 等待进程进入下一个系统调用。
2. 输出系统调用的一个描述。
3. 允许系统调用去运行并等待返回。
4. 输出系统调用返回值。
这个 `PTRACE_SYSCALL` 请求被用于等待下一个系统调用时开始，和等待那个系统调用退出。和前面一样，需要一个 `wait(2)` 去等待被跟踪进程进入期望的状态。
```
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, 0, 0);
```
当 `wait(2)` 返回时，进行了系统调用的线程的寄存器中写入了该系统调用的系统调用号及其参数。尽管如此，*操作系统仍然没有为这个系统调用提供服务*。这个细节对后续操作很重要。
接下来的一步是采集系统调用信息。这是各个系统架构不同的地方。在 x86-64 上，[系统调用号是在 `rax` 中传递的](http://nullprogram.com/blog/2015/05/15/)，而参数（最多 6 个）是在 `rdi`、`rsi`、`rdx`、`r10`、`r8` 和 `r9` 中传递的。这些寄存器是由另外的 Ptrace 调用读取的，不过这里再也不需要 `wait(2)` 了，因为被跟踪进程的状态再也不会发生变化了。
```
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, 0, ®s);
long syscall = regs.orig_rax;
fprintf(stderr, "%ld(%ld, %ld, %ld, %ld, %ld, %ld)",
syscall,
(long)regs.rdi, (long)regs.rsi, (long)regs.rdx,
(long)regs.r10, (long)regs.r8, (long)regs.r9);
```
这里有一个警告。由于 [内核的内部用途](https://stackoverflow.com/a/6469069)，系统调用号是保存在 `orig_rax` 中而不是 `rax` 中。而所有的其它系统调用参数都是非常简单明了的。
接下来是它的另一个 `PTRACE_SYSCALL` 和 `wait(2)`，然后是另一个 `PTRACE_GETREGS` 去获取结果。结果保存在 `rax` 中。
```
ptrace(PTRACE_GETREGS, pid, 0, ®s);
fprintf(stderr, " = %ld\n", (long)regs.rax);
```
这个简单程序的输出也是非常粗糙的。这里的系统调用都没有符号名，并且所有的参数都是以数字形式输出，甚至是一个指向缓冲区的指针也是如此。更完整的 strace 输出将能知道哪个参数是指针，并使用 `process_vm_readv(2)` 从被跟踪进程中读取哪些缓冲区，以便正确输出它们。
然而，这些仅仅是系统调用拦截的基础工作。
### 系统调用拦截
假设我们想使用 Ptrace 去实现如 OpenBSD 的 [`pledge(2)`](https://man.openbsd.org/pledge.2) 这样的功能，它是 [一个进程<ruby> 承诺 <rt> pledge </rt></ruby>只使用一套受限的系统调用](http://www.openbsd.org/papers/hackfest2015-pledge/mgp00001.html)。初步想法是，许多程序一般都有一个初始化阶段，这个阶段它们都需要进行许多的系统访问（比如，打开文件、绑定套接字、等等）。初始化完成以后，它们进行一个主循环，在主循环中它们处理输入，并且仅使用所需的、很少的一套系统调用。
在进入主循环之前，一个进程可以限制它自己只能运行所需要的几个操作。如果 [程序有缺陷](http://nullprogram.com/blog/2017/07/19/)，能够通过恶意的输入去利用该缺陷，这个**承诺**可以有效地限制漏洞利用的实现。
使用与 strace 相同的模型，但不是输出所有的系统调用，我们既能够阻塞某些系统调用，也可以在它的行为异常时简单地终止被跟踪进程。终止它很容易：只需要在跟踪器中调用 `exit(2)`。因此，它也可以被设置为去终止被跟踪进程。阻塞系统调用和允许子进程继续运行都只是些雕虫小技而已。
最棘手的部分是**当系统调用启动后没有办法去中断它**。当跟踪器在入口从 `wait(2)` 中返回到系统调用时，从一开始停止一个系统调用的仅有方式是，终止被跟踪进程。
然而，我们不仅可以“搞乱”系统调用的参数，也可以改变系统调用号本身，将它修改为一个不存在的系统调用。返回时，在 `errno` 中 [通过正常的内部信号](http://nullprogram.com/blog/2016/09/23/)，我们就可以报告一个“友好的”错误信息。
```
for (;;) {
/* Enter next system call */
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, 0, 0);
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, 0, ®s);
/* Is this system call permitted? */
int blocked = 0;
if (is_syscall_blocked(regs.orig_rax)) {
blocked = 1;
regs.orig_rax = -1; // set to invalid syscall
ptrace(PTRACE_SETREGS, pid, 0, ®s);
}
/* Run system call and stop on exit */
ptrace(PTRACE_SYSCALL, pid, 0, 0);
waitpid(pid, 0, 0);
if (blocked) {
/* errno = EPERM */
regs.rax = -EPERM; // Operation not permitted
ptrace(PTRACE_SETREGS, pid, 0, ®s);
}
}
```
这个简单的示例只是检查了系统调用是否违反白名单或黑名单。而它们在这里并没有差别，比如，允许文件以只读而不是读写方式打开（`open(2)`），允许匿名内存映射但不允许非匿名映射等等。但是这里仍然没有办法去动态撤销被跟踪进程的权限。
跟踪器与被跟踪进程如何沟通？使用人为的系统调用！
### 创建一个人为的系统调用
对于我的这个类似于 pledge 的系统调用 —— 我可以通过调用 `xpledge()` 将它与真实的系统调用区分开 —— 我设置 10000 作为它的系统调用号，这是一个非常大的数字，真实的系统调用中从来不会用到它。
```
#define SYS_xpledge 10000
```
为演示需要，我同时构建了一个非常小的接口，这在实践中并不是个好主意。它与 OpenBSD 的 `pledge(2)` 稍有一些相似之处，它使用了一个 [字符串接口](https://www.tedunangst.com/flak/post/string-interfaces)。*事实上*，设计一个健壮且安全的权限集是非常复杂的，正如在 `pledge(2)` 的手册页面上所显示的那样。下面是对被跟踪进程的系统调用的完整接口*和*实现：
```
#define _GNU_SOURCE
#include <unistd.h>
#define XPLEDGE_RDWR (1 << 0)
#define XPLEDGE_OPEN (1 << 1)
#define xpledge(arg) syscall(SYS_xpledge, arg)
```
如果给它传递个参数 0 ，仅允许一些基本的系统调用，包括那些用于去分配内存的系统调用（比如 `brk(2)`）。 `PLEDGE_RDWR` 位允许 [各种](http://nullprogram.com/blog/2017/03/01/) 读和写的系统调用（`read(2)`、`readv(2)`、`pread(2)`、`preadv(2)` 等等）。`PLEDGE_OPEN` 位允许 `open(2)`。
为防止发生提升权限的行为，`pledge()` 会拦截它自己 —— 但这样也防止了权限撤销，以后再细说这方面内容。
在 xpledge 跟踪器中，我需要去检查这个系统调用：
```
/* Handle entrance */
switch (regs.orig_rax) {
case SYS_pledge:
register_pledge(regs.rdi);
break;
}
```
操作系统将返回 `ENOSYS`（函数尚未实现），因为它不是一个*真实的*系统调用。为此在退出时我用一个 `success(0)` 去覆写它。
```
/* Handle exit */
switch (regs.orig_rax) {
case SYS_pledge:
ptrace(PTRACE_POKEUSER, pid, RAX * 8, 0);
break;
}
```
我写了一小段测试程序去打开 `/dev/urandom`，做一个读操作，尝试去承诺后，然后试着第二次打开 `/dev/urandom`，然后确认它能够读取原始的 `/dev/urandom` 文件描述符。在没有承诺跟踪器的情况下运行，输出如下：
```
$ ./example
fread("/dev/urandom")[1] = 0xcd2508c7
XPledging...
XPledge failed: Function not implemented
fread("/dev/urandom")[2] = 0x0be4a986
fread("/dev/urandom")[1] = 0x03147604
```
做一个无效的系统调用并不会让应用程序崩溃。它只是失败，这是一个很方便的返回方式。当它在跟踪器下运行时，它的输出如下：
```
>$ ./xpledge ./example
fread("/dev/urandom")[1] = 0xb2ac39c4
XPledging...
fopen("/dev/urandom")[2]: Operation not permitted
fread("/dev/urandom")[1] = 0x2e1bd1c4
```
这个承诺很成功，第二次的 `fopen(3)` 并没有进行，因为跟踪器用一个 `EPERM` 阻塞了它。
可以将这种思路进一步发扬光大，比如，改变文件路径或返回一个假的结果。一个跟踪器可以很高效地 chroot 它的被跟踪进程，通过一个系统调用将任意路径传递给 root 从而实现 chroot 路径。它甚至可以对用户进行欺骗，告诉用户它以 root 运行。事实上，这些就是 [Fakeroot NG](https://fakeroot-ng.lingnu.com/index.php/Home_Page) 程序所做的事情。
### 仿真外部系统
假设你不满足于仅拦截一些系统调用，而是想拦截*全部*系统调用。你就会有了 [一个打算在其它操作系统上运行的二进制程序](http://nullprogram.com/blog/2017/11/30/)，无需系统调用，这个二进制程序可以一直运行。
使用我在前面所描述的这些内容你就可以管理这一切。跟踪器可以使用一个假冒的东西去代替系统调用号，允许它失败，以及为系统调用本身提供服务。但那样做的效率很低。其实质上是对每个系统调用做了三个上下文切换：一个是在入口上停止，一个是让系统调用总是以失败告终，还有一个是在系统调用退出时停止。
从 2005 年以后，对于这个技术，PTrace 的 Linux 版本有更高效的操作：`PTRACE_SYSEMU`。PTrace 仅在每个系统调用发出时停止*一次*，在允许被跟踪进程继续运行之前，由跟踪器为系统调用提供服务。
```
for (;;) {
ptrace(PTRACE_SYSEMU, pid, 0, 0);
waitpid(pid, 0, 0);
struct user_regs_struct regs;
ptrace(PTRACE_GETREGS, pid, 0, ®s);
switch (regs.orig_rax) {
case OS_read:
/* ... */
case OS_write:
/* ... */
case OS_open:
/* ... */
case OS_exit:
/* ... */
/* ... and so on ... */
}
}
```
从任何具有（足够）稳定的系统调用 ABI（LCTT 译注：应用程序二进制接口），在相同架构的机器上运行一个二进制程序时，你只需要 `PTRACE_SYSEMU` 跟踪器、一个加载器（用于代替 `exec(2)`），和这个二进制程序所需要（或仅运行静态的二进制程序）的任何系统库即可。
事实上，这听起来有点像一个有趣的周末项目。
**参见**
* [给 Linux 内核克隆实现一个 OpenBSD 承诺](https://www.youtube.com/watch?v=uXgxMDglxVM)
---
via: <http://nullprogram.com/blog/2018/06/23/>
作者：[Chris Wellons](http://nullprogram.com) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux DNS 查询剖析（第一部分）
|
Zwischenzugs
|
https://zwischenzugs.com/2018/06/08/anatomy-of-a-linux-dns-lookup-part-i/
|
“Linux 执行一次 DNS 查询”这句话的背后有相当多的工作。
|
/data/attachment/album/201808/22/230531lp6bml26u2mybkm2.jpeg.thumb.jpg
|
/data/attachment/album/201808/22/230531lp6bml26u2mybkm2.jpeg
| true | false | true |
pinewall
|
wxy
| false |
[
"DNS"
] |
技术
|
{
"viewnum": 12203,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9949,
"displayorder": 0
}
] |
“Linux 执行一次 DNS 查询”这句话的背后有相当多的工作。
| 2018-08-22T23:05:00 | 2018-08-22T23:05:00 | 9,943 |
/article-9943-1.html
|
我经常与虚拟机集群打交道（[文1](https://zwischenzugs.com/2017/10/31/a-complete-chef-infrastructure-on-your-laptop/)、[文2](https://zwischenzugs.com/2017/03/04/a-complete-openshift-cluster-on-vagrant-step-by-step/)、[文3](https://zwischenzugs.com/2017/03/04/migrating-an-openshift-etcd-cluster/)、[文4](https://zwischenzugs.com/2017/03/04/1-minute-multi-node-vm-setup/)、[文5](https://zwischenzugs.com/2017/03/18/clustered-vm-testing-how-to/)、[文6](https://zwischenzugs.com/2017/10/27/ten-things-i-wish-id-known-before-using-vagrant/)），因此最终花费了大量时间试图掌握 [DNS 查询](https://zwischenzugs.com/2017/10/21/openshift-3-6-dns-in-pictures/)的工作原理。遇到问题时，我只是不求甚解的使用 StackOverflow 上的“解决方案”，而不知道它们为什么有时工作，有时不工作。
最终我对此感到了厌倦，决定一并找出所有问题的原因。我没有在网上找到完整的指南，我问过一些同事，他们不知所以然（或许是问题太具体了）。
既然如此，我开始自己写这样的手册。
结果发现，“Linux 执行一次 DNS 查询”这句话的背后有相当多的工作。
*“究竟有多难呢？”*
**本系列文章试图将 Linux 主机上程序获取（域名对应的） IP 地址的过程及期间涉及的组件进行分块剖析。**如果不理解这些块的协同工作方式，调试解决 `dnsmasq`、`vagrant landrush` 和 `resolvconf` 等相关的问题会让人感到眼花缭乱。
同时这也是一份有价值的说明，指出原本很简单的东西是如何随着时间的推移变得相当复杂。在弄清楚 DNS 查询的原理的过程中，我了解了大量不同的技术及其发展历程。
我甚至编写了一些[自动化脚本](https://github.com/ianmiell/shutit-linux-dns/blob/master/linux_dns.py)，可以让我在虚拟机中进行实验。欢迎读者参与贡献或勘误。
**请注意，本系列主题并不是“DNS 工作原理”**，而是与查询 Linux 主机配置的真实 DNS 服务器（这里假设查询了一台 DNS 服务器，但后面你会看到有时并不需要）相关的内容，以及如何确定使用哪个查询结果，或者如何使用其它方式确定 IP 地址。
### 1) 其实并没有名为“DNS 查询”的系统调用
*工作方式并非如此*
**首先要了解的一点是，Linux 上并没有一个单独的方法可以完成 DNS 查询工作**；没有一个有这样的明确接口的核心<ruby> 系统调用 <rt> system call </rt></ruby>。
不过，有一个标准 C 库函数调用 [`getaddrinfo`](http://man7.org/linux/man-pages/man3/getaddrinfo.3.html)，不少程序使用了该调用；但不是所有程序或应用都使用该调用！
让我们看一下两个简单的标准程序：`ping` 和 `host`：
```
root@linuxdns1:~# ping -c1 bbc.co.uk | head -1
PING bbc.co.uk (151.101.192.81) 56(84) bytes of data.
```
```
root@linuxdns1:~# host bbc.co.uk | head -1
bbc.co.uk has address 151.101.192.81
```
对于同一个域名，两个程序得到的 IP 地址是相同的；那么它们是使用同样的方法得到结果的吧？
事实并非如此。
下面文件给出了我主机上 `ping` 对应的 DNS 相关的系统调用：
```
root@linuxdns1:~# strace -e trace=open -f ping -c1 google.com
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
open("/lib/x86_64-linux-gnu/libcap.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
open("/etc/resolv.conf", O_RDONLY|O_CLOEXEC) = 4
open("/etc/resolv.conf", O_RDONLY|O_CLOEXEC) = 4
open("/etc/nsswitch.conf", O_RDONLY|O_CLOEXEC) = 4
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 4
open("/lib/x86_64-linux-gnu/libnss_files.so.2", O_RDONLY|O_CLOEXEC) = 4
open("/etc/host.conf", O_RDONLY|O_CLOEXEC) = 4
open("/etc/hosts", O_RDONLY|O_CLOEXEC) = 4
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 4
open("/lib/x86_64-linux-gnu/libnss_dns.so.2", O_RDONLY|O_CLOEXEC) = 4
open("/lib/x86_64-linux-gnu/libresolv.so.2", O_RDONLY|O_CLOEXEC) = 4
PING google.com (216.58.204.46) 56(84) bytes of data.
open("/etc/hosts", O_RDONLY|O_CLOEXEC) = 4
64 bytes from lhr25s12-in-f14.1e100.net (216.58.204.46): icmp_seq=1 ttl=63 time=13.0 ms
[...]
```
下面是 `host` 对应的系统调用:
```
$ strace -e trace=open -f host google.com
[...]
[pid 9869] open("/usr/share/locale/en_US.UTF-8/LC_MESSAGES/libdst.cat", O_RDONLY) = -1 ENOENT (No such file or directory)
[pid 9869] open("/usr/share/locale/en/libdst.cat", O_RDONLY) = -1 ENOENT (No such file or directory)
[pid 9869] open("/usr/share/locale/en/LC_MESSAGES/libdst.cat", O_RDONLY) = -1 ENOENT (No such file or directory)
[pid 9869] open("/usr/lib/ssl/openssl.cnf", O_RDONLY) = 6
[pid 9869] open("/usr/lib/x86_64-linux-gnu/openssl-1.0.0/engines/libgost.so", O_RDONLY|O_CLOEXEC) = 6[pid 9869] open("/etc/resolv.conf", O_RDONLY) = 6
google.com has address 216.58.204.46
[...]
```
可以看出 `ping` 打开了 `nsswitch.conf` 文件，但 `host` 没有；但两个程序都打开了 `/etc/resolv.conf` 文件。
下面我们依次查看这两个 `.conf` 扩展名的文件。
### 2) NSSwitch 与 `/etc/nsswitch.conf`
我们已经确认应用可以自主决定选用哪个 DNS 服务器。很多应用（例如 `ping`）通过配置文件 `/etc/nsswitch.conf` （根据具体实现<sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup> ）参考 NSSwitch 完成选择。
NSSwitch 不仅用于 DNS 查询，例如，还用于密码与用户信息查询。
NSSwitch 最初是 Solaris OS 的一部分，可以让应用无需硬编码查询所需的文件或服务，而是在其它集中式的、无需应用开发人员管理的配置文件中找到。
下面是我的 `nsswitch.conf`：
```
passwd: compat
group: compat
shadow: compat
gshadow: files
hosts: files dns myhostname
networks: files
protocols: db files
services: db files
ethers: db files
rpc: db files
netgroup: nis
```
我们需要关注的是 `hosts` 行。我们知道 `ping` 用到 `nsswitch.conf` 文件，那么我们修改这个文件（的 `hosts` 行），看看能够如何影响 `ping`。
#### 修改 `nsswitch.conf`， `hosts` 行仅保留 `files`
如果你修改 `nsswitch.conf`，将 `hosts` 行仅保留 `files`：
```
hosts: files
```
此时， `ping` 无法获取 google.com 对应的 IP 地址：
```
$ ping -c1 google.com
ping: unknown host google.com
```
但 `localhost` 的解析不受影响：
```
$ ping -c1 localhost
PING localhost (127.0.0.1) 56(84) bytes of data.
64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.039 ms
```
此外，`host` 命令正常返回：
```
$ host google.com
google.com has address 216.58.206.110
```
毕竟如我们之前看到的那样，`host` 不受 `nsswitch.conf` 影响。
#### 修改 `nsswitch.conf`， `hosts` 行仅保留 `dns`
如果你修改 `nsswitch.conf`，将 `hosts` 行仅保留 `dns`：
```
hosts: dns
```
此时，google.com 的解析恢复正常：
```
$ ping -c1 google.com
PING google.com (216.58.198.174) 56(84) bytes of data.
64 bytes from lhr25s10-in-f174.1e100.net (216.58.198.174): icmp_seq=1 ttl=63 time=8.01 ms
```
但 `localhost` 无法解析：
```
$ ping -c1 localhost
ping: unknown host localhost
```
下图给出默认 NSSwitch 中 `hosts` 行对应的查询逻辑：
*我的 `hosts:` 配置是 `nsswitch.conf` 给出的默认值*
### 3) `/etc/resolv.conf`
我们已经知道 `host` 和 `ping` 都使用 `/etc/resolv.conf` 文件。
下面给出我主机的 `/etc/resolv.conf` 文件内容：
```
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 10.0.2.3
```
先忽略前两行，后面我们会回过头来看这部分（它们很重要，但你还需要一些知识储备）。
其中 `nameserver` 行指定了查询用到的 DNS 服务器。
如果将该行注释掉：
```
#nameserver 10.0.2.3
```
再次运行：
```
$ ping -c1 google.com
ping: unknown host google.com
```
解析失败了，这是因为没有可用的名字服务器 <sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup>。
该文件中还可以使用其它选项。例如，你可以在 `resolv.conf` 文件中增加如下行：
```
search com
```
然后执行 `ping google` （不写 `.com`）
```
$ ping google
PING google.com (216.58.204.14) 56(84) bytes of data.
```
程序会自动为你尝试 `.com` 域。
### 第一部分总结
第一部分到此结束，下一部分我们会了解 `resolv.conf` 文件是如何创建和更新的。
下面总结第一部分涵盖的内容：
* 操作系统中并不存在“DNS 查询”这个系统调用
* 不同程序可能采用不同的策略获取名字对应的 IP 地址
+ 例如, `ping` 使用 `nsswitch`，后者进而使用（或可以使用） `/etc/hosts`、`/etc/resolv.conf` 以及主机名得到解析结果
* `/etc/resolv.conf` 用于决定：
+ 查询什么地址（LCTT 译注：这里可能指 `search` 带来的影响）
+ 使用什么 DNS 服务器执行查询
如果你曾认为 DNS 查询很复杂，请跟随这个系列学习吧。
---
1. `ping` 实现的变种之多令人惊叹。我 *不* 希望在这里讨论过多。 [↩](#fnref1)
2. 另一个需要注意的地方： `host` 在没有指定 nameserver 的情况下会尝试 127.0.0.1:53。 [↩](#fnref2)
---
via: <https://zwischenzugs.com/2018/06/08/anatomy-of-a-linux-dns-lookup-part-i/>
作者：[ZWISCHENZUGS](https://zwischenzugs.com/) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何在 Linux 中切换相同程序的不同版本
|
Sk
|
https://www.ostechnix.com/how-to-switch-between-different-versions-of-commands-in-linux/
|
alt 是一个命令行工具，可以让你在类 Unix 系统中切换相同程序的不同版本。
|
/data/attachment/album/201808/22/233454yc7byupd01dy7m33.jpg.thumb.jpg
|
/data/attachment/album/201808/22/233454yc7byupd01dy7m33.jpg
| true | false | true |
lujun9972
|
pinewall
|
wxy
| false |
[
"版本",
"alt"
] |
技术
|
{
"viewnum": 6683,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
alt 是一个命令行工具，可以让你在类 Unix 系统中切换相同程序的不同版本。
| 2018-08-22T23:15:00 | 2018-08-22T23:15:00 | 9,944 |
/article-9944-1.html
|
几天前，我们曾经讨论[如何在不同的 PHP 版本之间进行切换](/article-9951-1.html)。在那篇文章中，我们使用 `update-alternatives` 命令实现从一个 PHP 版本切换到另一个 PHP 版本。也就是说，`update-alternatives` 命令可以将<ruby> 系统范围 <rt> system wide </rt></ruby>默认使用的 PHP 版本设置为我们希望的版本。通俗的来说，你可以通过 `update-alternatives` 命令从系统范围设置程序的版本。如果你希望可以在不同目录动态设置不同的程序版本，该如何完成呢？在这种情况下，`alt` 工具可以大显身手。`alt` 是一个命令行工具，可以让你在类 Unix 系统中切换相同程序的不同版本。该工具简单易用，是 Rust 语言编写的自由、开源软件。
### 安装
安装 `alt` 工具十分简单。
运行如下命令，即可在 Linux 主机上安装 `alt`：
```
$ curl -sL https://github.com/dotboris/alt/raw/master/install.sh | bash -s
```
下一步，将 `shims` 目录添加到你的 PATH 环境变量中，具体操作取决于你使用的 Shell。
对于 Bash：
```
$ echo 'export PATH="$HOME/.local/alt/shims:$PATH"' >> ~/.bashrc
$ source ~/.bashrc
```
对于 Zsh：
```
$ echo 'export PATH="$HOME/.local/alt/shims:$PATH"' >> ~/.zshrc
$ source ~/.zshrc
```
对于 Fish：
```
$ echo 'set -x PATH "$HOME/.local/alt/shims" $PATH' >> ~/.config/fish/config.fish
```
现在 `alt` 已经安装完毕！
### 使用 alt 工具在 Linux 系统中切换相同程序的不同版本
如我之前所述，alt 只影响当前目录。换句话说，当你进行版本切换时，只在当前目录生效，而不是整个系统范围。
下面举例说明。我在我的 Ubuntu 系统中安装了两个版本的 PHP，分别为 PHP 5.6 和 PHP 7.2；另外，在 `myproject` 目录中包含一些 PHP 应用。
首先，通过命令查看系统范围默认的 PHP 版本：
```
$ php -v
```
示例输出：
如截图中所示，我系统中默认的 PHP 版本为 PHP 7.2。
然后，我将进入放置 PHP 应用的 `myproject` 目录。
```
$ cd myproject
```
使用如下命令扫描可用的 PHP 版本：
```
$ alt scan php
```
示例输出：
可见，我有两个 PHP 版本，即 PHP 5.6 和 PHP 7.2。按下 `<空格>` 键选中当前可用的版本。选中全部可用版本后，你可以看到图中所示的<ruby> 叉号 <rt> cross mark </rt></ruby>。使用上下方向键在版本间移动，点击回车即可保存变更。
下面运行该命令并选取我们希望在 `myproject` 目录中使用的 PHP 版本：
```
$ alt use php
```
我希望使用 PHP5.6 版本，故我（使用方向键）选取该版本并点击回车键。
现在，你可以在 `/home/sk/myproject` 目录下使用 PHP 5.6 版本啦。
让我们检查一下，在 `myproject` 目录下是否默认使用 PHP 5.6 版本：
```
$ php -v
```
示例输出：
只要你不设置成其它版本，（在该目录下）将一直使用 PHP 5.6 版本。清楚了吗？很好！请注意，我们仅在这个目录下使用 PHP 5.6 版本。在系统范围内（LCTT 译注：当然是没单独设置过其它版本的目录下），PHP 7.2 仍是默认的版本。让我们检验一下，请看下图。
从上面的截图中可以看出，我有两个版本的 PHP：在 `myproject` 目录下，使用的版本为 PHP 5.6；在 `myproject` 外的其它目录，使用的版本为 PHP 7.2。
同理，你可以为每个目录设置你希望的程序版本。我这里使用 PHP 仅用于说明操作，但方法适用于任何你打算使用的软件，例如 NodeJS 等。
下面是 NodeJS 的示例视频。
如果你希望在不同软件包版本下测试你的应用，那么 `alt` 是你不错的选择。
本次分享到此结束。后续还有更多内容，敬请期待！
干杯！
---
via: <https://www.ostechnix.com/how-to-switch-between-different-versions-of-commands-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Docker 的用户名字空间功能
|
Koji Tanaka
|
https://coderwall.com/p/s_ydlq/using-user-namespaces-on-docker
|
该功能允许主机系统将自身的 uid 和 gid 映射为容器进程中的另一个 uid 和 gid。这对 Docker 的安全性来说是一项巨大的改进。
|
/data/attachment/album/201808/23/210106uc2zzto0bqvql8bb.png.thumb.jpg
|
/data/attachment/album/201808/23/210106uc2zzto0bqvql8bb.png
| true | false | true |
lujun9972
|
lujun9972
|
pityonline
| false |
[
"名字空间",
"Docker"
] |
容器与云
|
{
"viewnum": 6755,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
该功能允许主机系统将自身的 uid 和 gid 映射为容器进程中的另一个 uid 和 gid。这对 Docker 的安全性来说是一项巨大的改进。
| 2018-08-23T21:02:00 | 2018-08-23T21:02:00 | 9,945 |
/article-9945-1.html
|
<ruby> 用户名字空间 <rt> User Namespaces </rt></ruby> 于 Docker 1.10 版本正式纳入其中，该功能允许主机系统将自身的 `uid` 和 `gid` 映射为容器进程中的另一个 `uid` 和 `gid`。这对 Docker 的安全性来说是一项巨大的改进。下面我会通过一个案例来展示一下用户名字空间能够解决的问题，以及如何启用该功能。
### 创建一个 Docker Machine
如果你已经创建好了一台用来试验用户名字空间的 docker <ruby> 机器 <rt> Machine </rt></ruby>，那么可以跳过这一步。我在自己的 Macbook 上安装了 Docker Toolbox，因此我只需用 `docker-machine` 命令就很简单地创建一个基于 VirtualBox 的 Docker 机器（这里假设主机名为 `host1`）：
```
# Create host1
$ docker-machine create --driver virtualbox host1
# Login to host1
$ docker-machine ssh host1
```
### 理解在用户名字空间未启用的情况下，非 root 用户能做什么
在启用用户名字空间前，我们先来看一下会有什么问题。Docker 到底哪个地方做错了？首先，使用 Docker 的一大优势在于用户在容器中可以拥有 root 权限，因此用户可以很方便地安装软件包。但是在 Linux 容器技术中这也是一把双刃剑。只要经过少许操作，非 root 用户就能以 root 的权限访问主机系统中的内容，比如 `/etc`。下面是操作步骤。
```
# Run a container and mount host1's /etc onto /root/etc
$ docker run --rm -v /etc:/root/etc -it ubuntu
# Make some change on /root/etc/hosts
root@34ef23438542:/# vi /root/etc/hosts
# Exit from the container
root@34ef23438542:/# exit
# Check /etc/hosts
$ cat /etc/hosts
```
你可以看到，步骤简单到难以置信，很明显 Docker 并不适用于运行在多人共享的电脑上。但是现在，通过用户名字空间，Docker 可以避免这个问题。
### 启用用户名字空间
```
# Create a user called "dockremap"
$ sudo adduser dockremap
# Setup subuid and subgid
$ sudo sh -c 'echo dockremap:500000:65536 > /etc/subuid'
$ sudo sh -c 'echo dockremap:500000:65536 > /etc/subgid'
```
然后，打开 `/etc/init.d/docker`，并在 `/usr/local/bin/docker daemon` 后面加上 `--userns-remap=default`，像这样：
```
$ sudo vi /etc/init.d/docker
/usr/local/bin/docker daemon --userns-remap=default -D -g "$DOCKER_DIR" -H unix:// $DOCKER_HOST $EXTRA_ARGS >> "$DOCKER_LOGFILE" 2>&1 &
```
然后重启 Docker：
```
$ sudo /etc/init.d/docker restart
```
这就完成了！
**注意**：若你使用的是 CentOS 7，则你需要了解两件事。
1. 内核默认并没有启用用户名字空间。运行下面命令并重启系统，可以启用该功能。
```
sudo grubby --args="user_namespace.enable=1" \
--update-kernel=/boot/vmlinuz-3.10.0-XXX.XX.X.el7.x86_64
```
2. CentOS 7 使用 `systemctl` 来管理服务，因此你需要编辑的文件是 `/usr/lib/systemd/system/docker.service`。
### 确认用户名字空间是否正常工作
若一切都配置妥当，则你应该无法再在容器中编辑 host1 上的 `/etc` 了。让我们来试一下。
```
# Create a container and mount host1's /etc to container's /root/etc
$ docker run --rm -v /etc:/root/etc -it ubuntu
# Check the owner of files in /root/etc, which should be "nobody nogroup".
root@d5802c5e670a:/# ls -la /root/etc
total 180
drwxr-xr-x 11 nobody nogroup 1100 Mar 21 23:31 .
drwx------ 3 root root 4096 Mar 21 23:50 ..
lrwxrwxrwx 1 nobody nogroup 19 Mar 21 23:07 acpi -> /usr/local/etc/acpi
-rw-r--r-- 1 nobody nogroup 48 Mar 10 22:09 boot2docker
drwxr-xr-x 2 nobody nogroup 60 Mar 21 23:07 default
# Try creating a file in /root/etc
root@d5802c5e670a:/# touch /root/etc/test
touch: cannot touch '/root/etc/test': Permission denied
# Try deleting a file
root@d5802c5e670a:/# rm /root/etc/hostname
rm: cannot remove '/root/etc/hostname': Permission denied
```
好了，太棒了。这就是用户名字空间的工作方式。
---
via: <https://coderwall.com/p/s_ydlq/using-user-namespaces-on-docker>
作者：[Koji Tanaka](https://coderwall.com/kjtanaka) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lujun9972](https://github.com/lujun9972) 校对：[pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
JavaScript 框架对比及案例（React、Vue 及 Hyperapp）
|
Angelos Chalaris
|
https://hackernoon.com/javascript-framework-comparison-with-examples-react-vue-hyperapp-97f064fb468d
|
在这篇文章中，我将尽可能客观的通过提供一些最小化的例子来比较这三个框架，以展示它们的能力。
|
/data/attachment/album/201808/23/230854lnotvaoeapi6oamv.jpg.thumb.jpg
|
/data/attachment/album/201808/23/230854lnotvaoeapi6oamv.jpg
| true | false | true |
Bestony
|
wxy
| false |
[
"JavaScript",
"框架"
] |
软件开发
|
{
"viewnum": 6080,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我将尽可能客观的通过提供一些最小化的例子来比较这三个框架，以展示它们的能力。
| 2018-08-23T23:09:41 | 2018-08-23T23:09:41 | 9,947 |
/article-9947-1.html
|
在[我的上一篇文章中](https://hackernoon.com/i-abandonded-react-in-favor-of-hyperapp-heres-why-df65638f8a79)，我试图解释为什么我认为 [Hyperapp](https://hyperapp.js.org/) 是一个 [React](https://reactjs.org/) 或 [Vue](https://vuejs.org/) 的可用替代品，原因是，我发现它易于起步。许多人批评这篇文章，认为它自以为是，并没有给其它框架一个展示自己的机会。因此，在这篇文章中，我将尽可能客观的通过提供一些最小化的例子来比较这三个框架，以展示它们的能力。
### 耳熟能详的计时器例子
计时器可能是响应式编程中最常用的例子之一，极其易于理解：
* 你需要一个变量 `count` 保持对计数器的追踪。
* 你需要两个方法来增加或减少 `count` 变量的值。
* 你需要一种方法来渲染 `count` 变量，并将其呈现给用户。
* 你需要挂载到这两个方法上的两个按钮，以便在用户和它们产生交互时变更 `count` 变量。
下述代码是上述所有三个框架的实现：
*使用 React、Vue 和 Hyperapp 实现的计数器*
这里或许会有很多要做的事情，特别是当你并不熟悉其中的一个或多个步骤的时候，因此，我们来一步一步解构这些代码：
* 这三个框架的顶部都有一些 `import` 语句
* React 更推崇面向对象的范式，就是创建一个 `Counter` 组件的 `class`。Vue 遵循类似的范式，通过创建一个新的 `Vue` 类的实例并将信息传递给它来实现。最后，Hyperapp 坚持函数范式，同时完全彼此分离 `view`、`state`和`action`。
* 就 `count` 变量而言， React 在组件的构造函数内对其进行实例化，而 Vue 和 Hyperapp 则分别是在它们的 `data` 和 `state` 中设置这些属性。
* 继续看，你可能注意到 React 和 Vue 有相同的方法来与 `count` 变量进行交互。 React 使用继承自 `React.Component` 的 `setState` 方法来修改它的状态，而 Vue 直接修改 `this.count`。 Hyperapp 使用 ES6 的双箭头语法来实现这个方法，而据我所知，这是唯一一个推荐使用这种语法的框架，React 和 Vue 需要在它们的方法内使用 `this`。另一方面，Hyperapp 的方法需要将状态作为参数，这意味着可以在不同的上下文中重用它们。
* 这三个框架的渲染部分实际上是相同的。唯一的细微差别是 Vue 需要一个函数 `h` 作为参数传递给渲染器，事实上 Hyperapp 使用 `onclick` 替代 `onClick` ，以及基于每个框架中实现状态的方式引用 `count` 变量。
* 最后，所有的三个框架都被挂载到了 `#app` 元素上。每个框架都有稍微不同的语法，Vue 则使用了最直接的语法，通过使用元素选择器而不是使用元素来提供最大的通用性。
#### 计数器案例对比意见
同时比较所有的三个框架，Hyperapp 需要最少的代码来实现计数器，并且它是唯一一个使用函数范式的框架。然而，Vue 的代码在绝对长度上似乎更短一些，元素选择器的挂载方式是一个很好的增强。React 的代码看起来最多，但是并不意味着代码不好理解。
### 使用异步代码
偶尔你可能需要处理异步代码。最常见的异步操作之一是发送请求给一个 API。为了这个例子的目的，我将使用一个[占位 API] 以及一些假数据来渲染一个文章列表。必须做的事情如下：
* 在状态里保存一个 `posts` 的数组
* 使用一个方法和正确的 URL 来调用 `fetch()` ，等待返回数据，转化为 JSON，并最终使用接收到的数据更新 `posts` 变量。
* 渲染一个按钮，这个按钮将调用抓取文章的方法。
* 渲染有主键的 `posts` 列表。
*从一个 RESTFul API 抓取数据*
让我们分解上面的代码，并比较三个框架：
* 与上面的技术里例子类似，这三个框架之间的存储状态、渲染视图和挂载非常相似。这些差异与上面的讨论相同。
* 在三个框架中使用 `fetch()` 抓取数据都非常简单，并且可以像预期一样工作。然而其中的关键在于， Hyperapp 处理异步操作和其它两种框架有些不同。当数据被接收到并转换为 JSON 时，该操作将调用不同的同步动作以取代直接在异步操作中修改状态。
* 就代码长度而言，Hyperapp 依然只用最少的代码行数实现了相同的结果，但是 Vue 的代码看起来不那么的冗长，同时拥有最少的绝对字符长度。
#### 异步代码对比意见
无论你选择哪种框架，异步操作都非常简单。在应用异步操作时， Hyperapp 可能会迫使你去遵循编写更加函数化和模块化的代码的方式。但是另外两个框架也确实可以做到这一点，并且在这一方面给你提供更多的选择。
### To-Do 列表组件案例
在响应式编程中，最出名的例子可能是使用每一个框架里来实现 To-Do 列表。我不打算在这里实现整个部分，我只实现一个无状态的组件，来展示三个框架如何创建更小的可复用的块来协助构建应用程序。
*示例 TodoItem 实现*
上面的图片展示了每一个框架一个例子，并为 React 提供了一个额外的例子。接下来是我们从它们四个中看到的：
* React 在编程范式上最为灵活。它支持函数组件，也支持类组件。它还支持你在右下角看到的 Hyperapp 组件，无需任何修改。
* Hyperapp 还支持 React 的函数组件实现，这意味着两个框架之间还有很多的实验空间。
* 最后出现的 Vue 有着其合理而又奇怪的语法，即使是对另外两个框架很有经验的人，也不能马上理解其含义。
* 在长度方面，所有的案例代码长度非常相似，在 React 的一些方法中稍微冗长一些。
#### To-Do 列表项目对比意见
Vue 需要花费一些时间来熟悉，因为它的模板和其它两个框架有一些不同。React 非常的灵活，支持多种不同的方法来创建组件，而 HyperApp 保持一切简单，并提供与 React 的兼容性，以免你希望在某些时刻进行切换。
### 生命周期方法比较
另一个关键对比是组件的生命周期事件，每一个框架允许你根据你的需要来订阅和处理事件。下面是我根据各框架的 API 参考手册创建的表格：
*生命周期方式比较*
* Vue 提供了最多的生命周期钩子，提供了处理生命周期事件之前或之后发生的任何事件的机会。这能有效帮助管理复杂的组件。
* React 和 Hyperapp 的生命周期钩子非常类似，React 将 `unmount` 和 `destory` 绑定在了一起，而 Hyperapp 则将 `create` 和 `mount` 绑定在了一起。两者在处理生命周期事件方面都提供了相当多的控制。
* Vue 根本没有处理 `unmount` （据我所理解），而是依赖于 `destroy` 事件在组件稍后的生命周期进行处理。 React 不处理 `destory` 事件，而是选择只处理 `unmount` 事件。最终，HyperApp 不处理 `create` 事件，取而代之的是只依赖 `mount` 事件。
#### 生命周期对比意见
总的来说，每个框架都提供了生命周期组件，它们帮助你处理组件生命周期中的许多事情。这三个框架都为它们的生命周期提供了钩子，其之间的细微差别，可能源自于实现和方案上的根本差异。通过提供更细粒度的时间处理，Vue 可以更进一步的允许你在开始或结束之后处理生命周期事件。
### 性能比较
除了易用性和编码技术以外，性能也是大多数开发人员考虑的关键因素，尤其是在进行更复杂的应用程序时。[js-framework-benchmark](https://github.com/krausest/js-framework-benchmark) 是一个很好的用于比较框架的工具，所以让我们看看每一组测评数据数组都说了些什么：
*测评操作表*
* 与三个框架的有主键操作相比，无主键操作更快。
* 无主键的 React 在所有六种对比中拥有最强的性能，它在所有测试上都有令人深刻的表现。
* 有主键的 Vue 只比有主键的 React 性能稍强，而无主键的 Vue 要比无主键的 React 性能明显差。
* Vue 和 Hyperapp 在进行局部更新的性能测试时遇见了一些问题，与此同时，React 似乎对该问题进行很好的优化。
*启动测试*
* Hyperapp 是三个框架中最轻量的，而 React 和 Vue 有非常小的大小差异。
* Hyperapp 具有最快的启动时间，这得益于它极小的大小和极简的 API
* Vue 在启动上比 React 好一些，但是差异非常小。
*内存分配测试*
* Hyperapp 是三者中对资源依赖最小的一个，与其它两者相比，任何一个操作都需要更少的内存。
* 资源消耗不是非常高，三者都应该在现代硬件上进行类似的操作。
#### 性能对比意见
如果性能是一个问题，你应该考虑你正在使用什么样的应用程序以及你的需求是什么。看起来 Vue 和 React 用于更复杂的应用程序更好，而 Hyperapp 更适合于更小的应用程序、更少的数据处理和需要快速启动的应用程序，以及需要在低端硬件上工作的应用程序。
但是，要记住，这些测试远不能代表一般场景，所以在现实场景中可能会看到不同的结果。
### 额外备注
比较 React、Vue 和 Hyperapp 可能像在许多方面比较苹果、橘子。关于这些框架还有一些其它的考虑，它们可以帮助你决定使用另一个框架。
* React 通过引入[片段](https://reactjs.org/docs/fragments.html)，避免了相邻的 JSX 元素必须封装在父元素中的问题，这些元素允许你将子元素列表分组，而无需向 DOM 添加额外的节点。
* React 还为你提供[更高级别的组件](https://reactjs.org/docs/higher-order-components.html)，而 VUE 为你提供重用组件功能的 [MIXIN](https://vuejs.org/v2/guide/mixins.html)。
* Vue 允许使用[模板](https://vuejs.org/v2/guide/syntax.html)来分离结构和功能，从而更好的分离关注点。
* 与其它两个相比，Hyperapp 感觉像是一个较低级别的 API，它的代码短得多，如果你愿意调整它并学习它的工作原理，那么它可以提供更多的通用性。
### 结论
我认为如果你已经阅读了这么多，你已经知道哪种工具更适合你的需求。毕竟，这不是讨论哪一个更好，而是讨论哪一个更适合每种情况。总而言之:
* React 是一个非常强大的工具，围绕它有大规模的开发者社区，可能会帮助你找到一个工作。入门并不难，但是掌握它肯定需要很多时间。然而，这是非常值得去花费你的时间全面掌握的。
* 如果你过去曾使用过另外的 JavaScript 框架，Vue 可能看起来有点奇怪，但它也是一个非常有趣的工具。如果 React 不是你所喜欢的，那么它可能是一个可行的、值得学习的选择。它有一些非常酷的内置功能，其社区也在增长中，甚至可能要比 React 增长还要快。
* 最后，Hyperapp 是一个为小型项目而生的很酷的小框架，也是初学者入门的好地方。它提供比 React 或 Vue 更少的工具，但是它能帮助你快速构建原型并理解许多基本原理。你为它编写的许多代码和其它两个框架兼容，要么立即能用，或者是稍做更改就行，你可以在对它们中另外一个有信心时切换框架。
---
作者简介：
喜欢编码的 Web 开发者，“30 秒编码” （ <https://30secondsofcode.org/> ）和 mini.css 框架（ <http://minicss.org> ） 的创建者。
---
via: <https://hackernoon.com/javascript-framework-comparison-with-examples-react-vue-hyperapp-97f064fb468d>
作者：[Angelos Chalaris](https://hackernoon.com/@chalarangelo?source=post_header_lockup)
译者：[Bestony](https://github.com/bestony)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何用 Python 读取 Outlook 中的电子邮件
|
A.a. Cetrefli
|
https://www.codementor.io/aliacetrefli/how-to-read-outlook-emails-by-python-jkp2ksk95
|
我使用一些代码来将 outlook 配置中的所有邮件写入一个临时文件中，现在让我来尝试解释一下这些代码。
|
/data/attachment/album/201808/24/054057kb56l2jblmb2jidb.jpg.thumb.jpg
|
/data/attachment/album/201808/24/054057kb56l2jblmb2jidb.jpg
| true | false | true |
lujun9972
|
lujun9972
|
wxy
| false |
[
"邮件",
"Outlook"
] |
软件开发
|
{
"viewnum": 25555,
"commentnum": 5,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "220.248.121.34",
"message": "f = open("testfile.txt","w+") <br />\r\n这个f是用来干嘛的",
"username": "来自上海的 Microsoft Edge 16.16299|Windows 10 用户",
"date": "2019-03-20T21:55:26"
},
{
"postip": "220.248.121.34",
"message": "f = open("testfile.txt","w+") <br />\r\n这个f是用来干嘛的",
"username": "来自上海的 Microsoft Edge 16.16299|Windows 10 用户",
"date": "2019-03-20T21:55:28"
},
{
"postip": "220.248.121.34",
"message": "f = open("testfile.txt","w+") <br />\r\n这个f是用来干嘛的",
"username": "来自上海的 Microsoft Edge 16.16299|Windows 10 用户",
"date": "2019-03-20T21:55:29"
},
{
"postip": "220.248.121.34",
"message": "f = open("testfile.txt","w+") <br />\r\n这个f是用来干嘛的",
"username": "来自上海的 Microsoft Edge 16.16299|Windows 10 用户",
"date": "2019-03-20T21:55:31"
},
{
"postip": "152.101.158.46",
"message": "明显楼主是搬来的， f = open("testfile.txt","w+")",
"username": "来自香港的 Chrome 89.0|Windows 10 用户",
"date": "2021-04-16T16:00:23"
}
] |
[] |
我使用一些代码来将 outlook 配置中的所有邮件写入一个临时文件中，现在让我来尝试解释一下这些代码。
| 2018-08-24T05:40:00 | 2018-08-24T05:40:00 | 9,948 |
/article-9948-1.html
|
从事电子邮件营销，<ruby> 准入 <rt> opt-in </rt></ruby>邮箱列表是必不可少的。你可能已经有了准入列表，同时还使用电子邮件客户端软件。如果你能从电子邮件客户端中导出准入列表，那这份列表想必是极好的。
我使用一些代码来将 outlook 配置中的所有邮件写入一个临时文件中，现在让我来尝试解释一下这些代码。
首先你需要导入 win32com.client，为此你需要安装 pywin32：
```
pip install pywin32
```
我们需要通过 MAPI 协议连接 Outlok：
```
outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
```
然后从 outlook 配置中获取所有的账户：
```
accounts= win32com.client.Dispatch("Outlook.Application").Session.Accounts;
```
在然后需要从名为 emaileri\_al 的收件箱中获取邮件：
```
def emailleri_al(folder):
messages = folder.Items
a=len(messages)
if a>0:
for message2 in messages:
try:
sender = message2.SenderEmailAddress
if sender != "":
print(sender, file=f)
except:
print("Ben hatayım")
print(account.DeliveryStore.DisplayName)
pass
try:
message2.Save
message2.Close(0)
except:
pass
```
你需要进入所有账户的所有收件箱中获取电子邮件：
```
for account in accounts:
global inbox
inbox = outlook.Folders(account.DeliveryStore.DisplayName)
print("****Account Name**********************************",file=f)
print(account.DisplayName,file=f)
print(account.DisplayName)
print("***************************************************",file=f)
folders = inbox.Folders
for folder in folders:
print("****Folder Name**********************************", file=f)
print(folder, file=f)
print("*************************************************", file=f)
emailleri_al(folder)
a = len(folder.folders)
if a>0 :
global z
z = outlook.Folders(account.DeliveryStore.DisplayName).Folders(folder.name)
x = z.Folders
for y in x:
emailleri_al(y)
print("****Folder Name**********************************", file=f)
print("..."+y.name,file=f)
print("*************************************************", file=
```
下面是完整的代码：
```
import win32com.client
import win32com
import os
import sys
f = open("testfile.txt","w+")
outlook = win32com.client.Dispatch("Outlook.Application").GetNamespace("MAPI")
accounts= win32com.client.Dispatch("Outlook.Application").Session.Accounts;
def emailleri_al(folder):
messages = folder.Items
a=len(messages)
if a>0:
for message2 in messages:
try:
sender = message2.SenderEmailAddress
if sender != "":
print(sender, file=f)
except:
print("Error")
print(account.DeliveryStore.DisplayName)
pass
try:
message2.Save
message2.Close(0)
except:
pass
for account in accounts:
global inbox
inbox = outlook.Folders(account.DeliveryStore.DisplayName)
print("****Account Name**********************************",file=f)
print(account.DisplayName,file=f)
print(account.DisplayName)
print("***************************************************",file=f)
folders = inbox.Folders
for folder in folders:
print("****Folder Name**********************************", file=f)
print(folder, file=f)
print("*************************************************", file=f)
emailleri_al(folder)
a = len(folder.folders)
if a>0 :
global z
z = outlook.Folders(account.DeliveryStore.DisplayName).Folders(folder.name)
x = z.Folders
for y in x:
emailleri_al(y)
print("****Folder Name**********************************", file=f)
print("..."+y.name,file=f)
print("*************************************************", file=f)
print("Finished Succesfully")
```
---
via: <https://www.codementor.io/aliacetrefli/how-to-read-outlook-emails-by-python-jkp2ksk95>
作者：[A.A. Cetrefli](https://www.codementor.io/aliacetrefli) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux DNS 查询剖析（第二部分）
|
Zwischenzugs
|
https://zwischenzugs.com/2018/06/18/anatomy-of-a-linux-dns-lookup-part-ii/
|
在第二部分中，我将介绍 resolv.conf 的更新机制、systemctl restart networking 命令的运行机制 ，以及 dhclient 是如何参与其中。
|
/data/attachment/album/201808/24/232313rb2ozk8zbbb29bb6.jpeg.thumb.jpg
|
/data/attachment/album/201808/24/232313rb2ozk8zbbb29bb6.jpeg
| true | false | true |
pinewall
|
wxy
| false |
[
"DNS"
] |
技术
|
{
"viewnum": 8060,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9943,
"displayorder": 0
},
{
"raid": 9972,
"displayorder": 0
}
] |
在第二部分中，我将介绍 resolv.conf 的更新机制、systemctl restart networking 命令的运行机制 ，以及 dhclient 是如何参与其中。
| 2018-08-24T23:23:00 | 2018-08-24T23:23:00 | 9,949 |
/article-9949-1.html
|
在 [Linux DNS 查询剖析 - 第一部分](/article-9943-1.html) 中，我介绍了：
* `nsswitch`
* `/etc/hosts`
* `/etc/resolv.conf`
* `ping` 与 `host` 查询方式对比
并且发现大多数程序选择要查询的 DNS 服务器时会参考 `/etc/resolv.conf` 配置文件。
这种方式在 Linux 上比较普遍<sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup>。虽然我使用了特定的发行版 Ubuntu，但背后的原理与 Debian 甚至是那些基于 CentOS 的发行版有相通的地方；当然，与更低或更高的 Ubuntu 版本相比，差异还是存在的。
也就是说，接下来，你主机上的行为很可能与我描述的不一致。
在第二部分中，我将介绍 `resolv.conf` 的更新机制、`systemctl restart networking` 命令的运行机制 ，以及 `dhclient` 是如何参与其中。
### 1) 手动更新 /etc/resolv.conf
我们知道 `/etc/resolv.conf` （有极大的可能性）被用到，故你自然可以通过该文件增加一个 `nameserver`，那么主机也将会（与已有的 `nameserver` 一起）使用新加入的 `nameserver` 吧？
你可以尝试如下：
```
$ echo nameserver 10.10.10.10 >> /etc/resolv.conf
```
看上去新的 `nameserver` 已经加入：
```
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 10.0.2.3
search home
nameserver 10.10.10.10
```
但主机网络服务重启后问题出现了：
```
$ systemctl restart networking
$ cat /etc/resolv.conf
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 10.0.2.3
search home
```
我们的 `10.10.10.10` 的 `nameserver` 不见了！
在上一篇文章中我们忽略了这一点，本文进行补充说明。
### 2) resolvconf
你在 `/etc/resolv.conf` 文件中看到 `generated by resolvconf` 词组了吧？这就是我们的线索。
如果深入研究 `systemctl restart networking` 命令，你会发现它做了很多事情，结束时调用了 `/etc/network/if-up.d/000resolvconf` 脚本。在该脚本中，可以发现一次对 `resolvconf` 命令的调用：
```
/sbin/resolvconf -a "${IFACE}.${ADDRFAM}"
```
稍微研究一下 man 手册，发现`-a` 参数允许我们：
```
Add or overwrite the record IFACE.PROG then run the update scripts
if updating is enabled.
```
（增加或覆盖 IFACE.PROG 记录，如果开启更新选项，则运行更新脚本）
故而也许我们可以直接调用该命令增加 `namserver`：
```
echo 'nameserver 10.10.10.10' | /sbin/resolvconf -a enp0s8.inet
```
测试表明确实可以！
```
$ cat /etc/resolv.conf | grep nameserver
nameserver 10.0.2.3
nameserver 10.10.10.10
```
是否已经找到答案，这就是 `/etc/resolv.conf` 更新的逻辑？调用 `resolvconf` 将 `nameserver` 添加到某个地方的数据库，然后（“如果配置了更新”，先不管具体什么含义）更新 `resolv.conf` 文件。
并非如此。
```
$ systemctl restart networking
root@linuxdns1:/etc# cat /etc/resolv.conf
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 10.0.2.3
search home
```
呃！（网络服务重启后）新增的 `nameserver` 再次消失了。
可见，`systemctl restart networking` 不仅仅运行了 `resolvconf`，还在其它地方获取 `nameserver` 信息。具体是哪里呢？
### 3) ifup/ifdown
继续深入研究 `systemctl restart networking`，发现它完成了一系列工作：
```
cat /lib/systemd/system/networking.service
[...]
[Service]
Type=oneshot
EnvironmentFile=-/etc/default/networking
ExecStartPre=-/bin/sh -c '[ "$CONFIGURE_INTERFACES" != "no" ] && [ -n "$(ifquery --read-environment --list --exclude=lo)" ] && udevadm settle'
ExecStart=/sbin/ifup -a --read-environment
ExecStop=/sbin/ifdown -a --read-environment --exclude=lo
[...]
```
首先，网络服务的重启实质是运行一个<ruby> 单触发 <rt> oneshot </rt></ruby>的脚本，脚本包含如下命令：
```
/sbin/ifdown -a --read-environment --exclude=lo
/bin/sh -c '[ "$CONFIGURE_INTERFACES" != "no" ] && [ -n "$(ifquery --read-environment --list --exclude=lo)" ] && udevadm settle'
/sbin/ifup -a --read-environment
```
第一行使用 `ifdown` 关闭全部的网络接口，但<ruby> 本地回环 <rt> local, lo </rt></ruby>接口除外。<sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup>
（LCTT 译注：其实这是因为很快就又启动了接口，间隔的时间没有超过 TCP 连接的超时时间，有人在评论中也做了类似回复）
第二行用于确认系统已经完成关闭网络接口相关的全部工作，以便下一步使用 `ifup` 启动接口。这也让我们了解到，网络服务实质运行的就是 `ifdown` 和 `ifup`。
文档中没有找到 `--read-environment` 参数的说明，该参数为 `systemctl` 正常工作所需。很多人以文档不完善为由不喜欢 `systemctl`。
很好。那么 `ifup` （和其成对出现的 `ifdown`） 到底做了哪些工作呢？长话短说，它运行了 `/etc/network/if-pre-up.d/` 和 `/etc/network/if-up.d/` 目录下的全部脚本；期间，这些脚本也可能会调用另外的脚本，依此类推。
其中一件工作就是运行了 `dhclient`，但我还不完全确定具体的机理，也许 `udev` 参与其中。
### 4) dhclient
`dhclient` 是一个程序，用于与 DHCP 服务器协商对应网络接口应该使用的 IP 地址的详细信息。同时，它也可以获取可用的 DNS 服务器并将其替换到 `/etc/resolv.conf` 中。
让我们开始跟踪并模拟它的行为，但仅在我实验虚拟机的 `enp0s3` 接口上。事先已经删除 `/etc/resolv.conf` 文件中的 nameserver 配置：
```
$ sed -i '/nameserver.*/d' /run/resolvconf/resolv.conf
$ cat /etc/resolv.conf | grep nameserver
$ dhclient -r enp0s3 && dhclient -v enp0s3
Killed old client process
Internet Systems Consortium DHCP Client 4.3.3
Copyright 2004-2015 Internet Systems Consortium.
All rights reserved.
For info, please visit https://www.isc.org/software/dhcp/
Listening on LPF/enp0s8/08:00:27:1c:85:19
Sending on LPF/enp0s8/08:00:27:1c:85:19
Sending on Socket/fallback
DHCPDISCOVER on enp0s8 to 255.255.255.255 port 67 interval 3 (xid=0xf2f2513e)
DHCPREQUEST of 172.28.128.3 on enp0s8 to 255.255.255.255 port 67 (xid=0x3e51f2f2)
DHCPOFFER of 172.28.128.3 from 172.28.128.2
DHCPACK of 172.28.128.3 from 172.28.128.2
bound to 172.28.128.3 -- renewal in 519 seconds.
$ cat /etc/resolv.conf | grep nameserver
nameserver 10.0.2.3
```
可见这就是 `nameserver` 的来源。
但稍等一下，命令中的 `/run/resolvconf/resolv.conf` 是哪个文件，不应该是 `/etc/resolv.conf` 吗？
事实上，`/etc/resolv.conf` 并不一定只是一个普通文本文件。
在我的虚拟机上，它是一个软链接，指向位于 `/run/resolvconf` 目录下的“真实文件”。这也暗示了我们，该文件是在系统启动时生成的；同时，这也是该文件注释告诉我们不要直接修改该文件的原因。
（LCTT 译注：在 CentOS 7 中，没有 `resolvconf` 命令，`/etc/resolv.conf` 也不是软链接）
假如上面命令中 `sed` 命令直接处理 `/etc/resolv.conf` 文件，效果是不同的，会有警告消息告知待操作的文件不能是软链接（`sed -i` 无法很好的处理软链接，它只会创建一个新文件）。
（LCTT 译注：CentOS 7 测试时，`sed -i` 命令操作软链接并没有警告，但确实创建了新文件取代软链接）
如果你继续深入查看配置文件 `/etc/dhcp/dhclient.conf` 的 `supersede` 部分，你会发现 `dhclient` 可以覆盖 DHCP 提供的 DNS 服务器。
*（大致）准确的关系图*
---
### 第二部分的结束语
第二部分到此结束。信不信由你，这是一个某种程度上简化的流程版本，但我尽量保留重要和值得了解的部分，让你不会感到无趣。大部分内容都是围绕实际脚本的运行展开的。
但我们的工作还没有结束，在第三部分，我们会介绍这些之上的更多层次。
让我们简要列出我们已经介绍过的内容：
* `nsswitch`
* `/etc/hosts`
* `/etc/resolv.conf`
* `/run/resolvconf/resolv.conf`
* `systemd` 和网络服务
* `ifup` 和 `ifdown`
* `dhclient`
* `resolvconf`
---
1. 事实上，这是相对于 POSIX 标准的，故不限于 Linux （我从上一篇文章的一条极好的[回复](https://zwischenzugs.com/2018/06/08/anatomy-of-a-linux-dns-lookup-part-i/#comment-2312)中了解到这一点） [↩](#fnref1)
2. 我不明白为何这没有导致我例子中的 vagrant 会话中断 （有谁明白吗？）。 [↩](#fnref2)
---
via: <https://zwischenzugs.com/2018/06/18/anatomy-of-a-linux-dns-lookup-part-ii/>
作者：[ZWISCHENZUGS](https://zwischenzugs.com/)
译者：[pinewall](https://github.com/pinewall)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
6 个简单的方式来查看 Linux 中的用户名和其它信息
|
Prakash Subramanian
|
https://www.2daygeek.com/6-easy-ways-to-check-user-name-and-other-information-in-linux/
|
你可能会问，为什么要讨论这个基础话题呢？即使我也这么认为，因为除了这两个之外没有更好的方法了，但是我们也有一些不错的选择。
|
/data/attachment/album/201808/25/085844v71epo9vqgac6au2.jpg.thumb.jpg
|
/data/attachment/album/201808/25/085844v71epo9vqgac6au2.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"passwd",
"user"
] |
技术
|
{
"viewnum": 22877,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你可能会问，为什么要讨论这个基础话题呢？即使我也这么认为，因为除了这两个之外没有更好的方法了，但是我们也有一些不错的选择。
| 2018-08-25T08:54:00 | 2018-08-25T08:54:00 | 9,950 |
/article-9950-1.html
|
这是一个非常基础的话题，在 Linux 中，每个人都知道如何使用 `id` 来查找用户信息。一些用户也从 `/etc/passwd` 文件中过滤用户信息。
我们还使用其它命令来获取用户信息。
你可能会问，为什么要讨论这个基础话题呢？即使我也这么认为，因为除了这两个之外没有更好的方法了，但是我们也有一些不错的选择。
与这两者相比，那些命令提供了更详细的信息，这对于新手非常有帮助。
这是帮助管理员在 Linux 中查找用户信息的基本命令之一。Linux 中的一切都是文件，甚至用户信息都存储在一个文件中。
建议阅读：
* [怎样在 Linux 上查看用户创建的日期](https://www.2daygeek.com/how-to-check-user-created-date-on-linux/)
* [怎样在 Linux 上查看用户属于哪个组](https://www.2daygeek.com/how-to-check-which-groups-a-user-belongs-to-on-linux/)
* [怎样在 Linux 上查看强制用户在下次登录时改变密码](https://www.2daygeek.com/how-to-force-user-to-change-password-on-next-login-in-linux/)
所有用户都被添加在 `/etc/passwd` 文件中，这里保留了用户名和其它相关详细信息。在 Linux 中创建用户时，用户详细信息将存储在 `/etc/passwd` 文件中。passwd 文件将每个用户详细信息保存为一行，包含 7 字段。
我们可以使用以下 6 种方法来查看用户信息。
* `id`：为指定的用户名打印用户和组信息。
* `getent`：从 Name Service Switch 库中获取条目。
* `/etc/passwd`： 文件包含每个用户的详细信息，每个用户详情是一行，包含 7 个字段。
* `finger`：用户信息查询程序
* `lslogins`：显示系统中已有用户的信息
* `compgen`：是 bash 内置命令，它将显示用户的所有可用命令。
### 1) 使用 id 命令
`id` 代表<ruby> 身份 <rt> identity </rt></ruby>。它输出真实有效的用户和组 ID。也可以输出指定用户或当前用户的用户和组信息。
```
# id daygeek
uid=1000(daygeek) gid=1000(daygeek) groups=1000(daygeek),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),118(lpadmin),128(sambashare)
```
下面是上述输出的详细信息：
* `uid (1000/daygeek)`： 它显示用户 ID 和用户名
* `gid (1000/daygeek)`： 它显示用户的组 ID 和名称
* `groups`： 它显示用户的附加组 ID 和名称
### 2) 使用 getent 命令
`getent` 命令显示 Name Service Switch 库支持的数据库中的条目，这些库在 `/etc/nsswitch.conf` 中配置。
`getent` 命令会显示类似于 `/etc/passwd` 文件的用户详情，它将每个用户的详细信息放在一行，包含 7 个字段。
```
# getent passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
magesh:x:502:503:2g Admin - Magesh M:/home/magesh:/bin/bash
thanu:x:503:504:2g Editor - Thanisha M:/home/thanu:/bin/bash
sudha:x:504:505:2g Editor - Sudha M:/home/sudha:/bin/bash
```
下面是关于 7 个字段的详细信息：
```
magesh:x:502:503:2g Admin - Magesh M:/home/magesh:/bin/bash
```
* `Username (magesh)`： 已创建的用户名。字符长度应该在 1 到 32 之间。
* `Password (x)`： 它表明加密密码存储在 `/etc/shadow` 文件中。
* `User ID (UID-502)`： 它表示用户 ID（UID），每个用户应包含唯一的 UID。UID (0-Zero) 保留给 root，UID（1-99）是为系统用户保留的，UID（100-999）是为系统账户/组保留的。
* `Group ID (GID-503)`： 它表示组 ID（GID），每个组应该包含唯一的 GID，它存储在 `/etc/group` 文件中。
* `User ID Info (2g Admin - Magesh M)`： 它表示命令字段。这个字段可用于描述用户信息。
* `Home Directory (/home/magesh)`： 它表示用户家目录。
* `shell (/bin/bash)`： 它表示用户的 bash shell。
如果你只想在 `getent` 命令的输出中显示用户名，使用以下命令格式：
```
# getent passwd | cut -d: -f1
root
bin
daemon
adm
lp
sync
shutdown
halt
mail
uucp
operator
games
gopher
magesh
thanu
sudha
```
只显示用户的家目录，使用以下命令格式：
```
# getent passwd | grep '/home' | cut -d: -f1
centos
prakash
magesh
thanu
sudha
```
### 3) 使用 /etc/passwd 文件
`/etc/passwd` 是一个文本文件，它包含每个用户登录 Linux 系统所必需的的信息。它维护用户的有用信息，如用户名，密码，用户 ID，组 ID，用户 ID 信息，家目录和 shell。`/etc/passwd` 文件将每个用户详细信息放在一行中，包含 7 个字段，如下所示：
```
# cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
magesh:x:502:503:2g Admin - Magesh M:/home/magesh:/bin/bash
thanu:x:503:504:2g Editor - Thanisha M:/home/thanu:/bin/bash
sudha:x:504:505:2g Editor - Sudha M:/home/sudha:/bin/bash
```
以下是 7 个字段的详细信息。
```
magesh:x:502:503:2g Admin - Magesh M:/home/magesh:/bin/bash
```
字段信息同上。
如果你只想显示 `/etc/passwd` 文件中的用户名，使用以下格式：
```
# cut -d: -f1 /etc/passwd
root
bin
daemon
adm
lp
sync
shutdown
halt
mail
uucp
operator
games
gopher
magesh
thanu
sudha
```
只显示用户的家目录，使用以下格式：
```
# cat /etc/passwd | grep '/home' | cut -d: -f1
centos
prakash
magesh
thanu
sudha
```
### 4) 使用 finger 命令
`finger` 命令显示有关系统用户的信息。它显示用户的真实姓名，终端名称和写入状态（如果没有写入权限，那么最为终端名称后面的 `*`），空闲时间和登录时间。
```
# finger magesh
Login: magesh Name: 2g Admin - Magesh M
Directory: /home/magesh Shell: /bin/bash
Last login Tue Jul 17 22:46 (EDT) on pts/2 from 103.5.134.167
No mail.
No Plan.
```
以下是上述输出的详细信息：
* `Login`： 用户名
* `Name`： 附加/有关用户的其它信息
* `Directory`： 用户家目录的信息
* `Shell`： 用户的 shell 信息
* `LAST-LOGIN`： 上次登录日期和其它信息
### 5) 使用 lslogins 命令
它显示系统已知用户的信息。默认情况下，它将列出系统中所有用户的信息。
`lslogins` 使用程序的灵感来自于 `logins` 实用程序，该实用程序最初出现在 FreeBSD 4.10 中。
```
# lslogins -u
UID USER PWD-LOCK PWD-DENY LAST-LOGIN GECOS
0 root 0 0 00:17:28 root
500 centos 0 1 Cloud User
501 prakash 0 0 Apr12/04:08 2018/04/12
502 magesh 0 0 Jul17/22:46 2g Admin - Magesh M
503 thanu 0 0 Jul18/00:40 2g Editor - Thanisha M
504 sudha 0 0 Jul18/01:18 2g Editor - Sudha M
```
以下是上述输出的详细信息：
* `UID`： 用户 id
* `USER`： 用户名
* `PWD-LOCK`： 密码已设置，但是已锁定
* `PWD-DENY`： 登录密码是否禁用
* `LAST-LOGIN`： 上次登录日期
* `GECOS`： 有关用户的其它信息
### 6) 使用 compgen 命令
`compgen` 是 bash 内置命令，它将显示所有可用的命令，别名和函数。（LCTT 译注：它的 `-u` 参数可以列出系统中用户。）
```
# compgen -u
root
bin
daemon
adm
lp
sync
shutdown
halt
mail
uucp
operator
games
gopher
magesh
thanu
sudha
```
---
via: <https://www.2daygeek.com/6-easy-ways-to-check-user-name-and-other-information-in-linux/>
作者：[Prakash Subramanian](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Ubuntu 中切换多个 PHP 版本
|
Sk
|
https://www.ostechnix.com/how-to-switch-between-multiple-php-versions-in-ubuntu/
|
在这个简短的教程中，我将向你展示如何在 Ubuntu 18.04 LTS 中切换多个 PHP 版本。它没你想的那么难。请继续阅读。
|
/data/attachment/album/201808/26/083933lu076fvl4w8li5n5.png.thumb.jpg
|
/data/attachment/album/201808/26/083933lu076fvl4w8li5n5.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"PHP",
"版本"
] |
系统运维
|
{
"viewnum": 7706,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这个简短的教程中，我将向你展示如何在 Ubuntu 18.04 LTS 中切换多个 PHP 版本。它没你想的那么难。请继续阅读。
| 2018-08-26T08:39:30 | 2018-08-26T08:39:30 | 9,951 |
/article-9951-1.html
|
有时，最新版本的安装包可能无法按预期工作。你的程序可能与更新的软件包不兼容，并且仅支持特定的旧版软件包。在这种情况下，你可以立即将有问题的软件包降级到其早期的工作版本。请参阅我们的旧指南，[在这](https://www.ostechnix.com/how-to-downgrade-a-package-in-ubuntu/)了解如何降级 Ubuntu 及其衍生版中的软件包以及[在这](https://www.ostechnix.com/how-to-downgrade-a-package-in-ubuntu/)了解如何降级 Arch Linux 及其衍生版中的软件包。但是，你无需降级某些软件包。我们可以同时使用多个版本。例如，假设你在测试部署在 Ubuntu 18.04 LTS 中的[LAMP 栈](https://www.ostechnix.com/install-apache-mariadb-php-lamp-stack-ubuntu-16-04/)的 PHP 程序。过了一段时间，你发现应用程序在 PHP 5.6 中工作正常，但在 PHP 7.2 中不正常（Ubuntu 18.04 LTS 默认安装 PHP 7.x）。你打算重新安装 PHP 或整个 LAMP 栈吗？但是没有必要。你甚至不必将 PHP 降级到其早期版本。在这个简短的教程中，我将向你展示如何在 Ubuntu 18.04 LTS 中切换多个 PHP 版本。它没你想的那么难。请继续阅读。
### 在多个 PHP 版本之间切换
要查看 PHP 的默认安装版本，请运行：
```
$ php -v
PHP 7.2.7-0ubuntu0.18.04.2 (cli) (built: Jul 4 2018 16:55:24) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies
with Zend OPcache v7.2.7-0ubuntu0.18.04.2, Copyright (c) 1999-2018, by Zend Technologies
```
如你所见，已安装的 PHP 的版本为 7.2.7。在测试你的程序几天后，你会发现你的程序不支持 PHP7.2。在这种情况下，同时使用 PHP5.x 和 PHP7.x 是个不错的主意，这样你就可以随时轻松地在任何支持的版本之间切换。
你不必删除 PHP7.x 或重新安装 LAMP 栈。你可以同时使用 PHP5.x 和 7.x 版本。
我假设你还没有在你的系统中卸载 PHP 5.6。万一你已将其删除，你可以使用下面的 PPA 再次安装它。
你可以从 PPA 中安装 PHP 5.6：
```
$ sudo add-apt-repository -y ppa:ondrej/php
$ sudo apt update
$ sudo apt install php5.6
```
#### 从 PHP 7.x 切换到 PHP 5.x.
首先使用命令禁用 PHP 7.2 模块：
```
$ sudo a2dismod php7.2
Module php7.2 disabled.
To activate the new configuration, you need to run:
systemctl restart apache2
```
接下来，启用 PHP 5.6 模块：
```
$ sudo a2enmod php5.6
```
将 PHP 5.6 设置为默认版本：
```
$ sudo update-alternatives --set php /usr/bin/php5.6
```
或者，你可以运行以下命令来设置默认情况下要使用的全局 PHP 版本。
```
$ sudo update-alternatives --config php
```
输入选择的号码将其设置为默认版本，或者只需按回车键保持当前选择。
如果你已安装其他 PHP 扩展，请将它们设置为默认值。
```
$ sudo update-alternatives --set phar /usr/bin/phar5.6
```
最后，重启 Apache Web 服务器：
```
$ sudo systemctl restart apache2
```
现在，检查 PHP 5.6 是否是默认版本：
```
$ php -v
PHP 5.6.37-1+ubuntu18.04.1+deb.sury.org+1 (cli)
Copyright (c) 1997-2016 The PHP Group
Zend Engine v2.6.0, Copyright (c) 1998-2016 Zend Technologies
with Zend OPcache v7.0.6-dev, Copyright (c) 1999-2016, by Zend Technologies
```
#### 从 PHP 5.x 切换到 PHP 7.x.
同样，你可以从 PHP 5.x 切换到 PHP 7.x 版本，如下所示。
```
$ sudo a2enmod php7.2
$ sudo a2dismod php5.6
$ sudo update-alternatives --set php /usr/bin/php7.2
$ sudo systemctl restart apache2
```
**提醒一句：**
最终稳定版 PHP 5.6 于 2017 年 1 月 19 日达到[**活跃支持截止**](http://php.net/supported-versions.php)。但是，直到 2018 年 12 月 31 日，PHP 5.6 将继续获得对关键安全问题的支持。所以，建议尽快升级所有 PHP 程序并与 PHP 7.x 兼容。
如果你希望防止 PHP 将来自动升级，请参阅以下指南。
就是这些了。希望这有帮助。还有更多的好东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-switch-between-multiple-php-versions-in-ubuntu/>
作者：[SK](https://www.ostechnix.com/author/sk/)
选题：[lujun9972](https://github.com/lujun9972)
译者：[geekpi](https://github.com/geekpi)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
对比 Ubuntu 18.04 和 Fedora 28
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/ubuntu-1804-vs-fedora-28
|
Ubuntu 和 Fedora 是两个主流的 Linux 发行版。两者都各自有一些华而不实的特性，因而新接触 Linux 的人很难抉择。我的建议是同时尝试二者，这样你在试用后可以发现哪个发行版提供的工具更适合你。
|
/data/attachment/album/201808/26/121105ntddq1rm5s6sq45r.jpg.thumb.jpg
|
/data/attachment/album/201808/26/121105ntddq1rm5s6sq45r.jpg
| true | false | true |
lujun9972
|
pinewall
|
wxy
| false |
[
"发行版",
"Linux"
] |
桌面应用
|
{
"viewnum": 11290,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ubuntu 和 Fedora 是两个主流的 Linux 发行版。两者都各自有一些华而不实的特性，因而新接触 Linux 的人很难抉择。我的建议是同时尝试二者，这样你在试用后可以发现哪个发行版提供的工具更适合你。
| 2018-08-26T12:12:41 | 2018-08-26T12:12:41 | 9,952 |
/article-9952-1.html
|
大家好，我准备在今天突出说明一下两大主流 Linux 发行版，即 **Ubuntu 18.04** 和 **Fedora 28**，包括一些特性和差异。两者都有各自的包管理系统，其中 Ubuntu 使用 DEB，Fedora 使用 RPM；但二者使用同样的[<ruby> 桌面环境 <rt> Desktop Environment </rt></ruby>](http://www.linuxandubuntu.com/home/5-best-linux-desktop-environments-with-pros-cons) （DE）[GNOME](http://www.linuxandubuntu.com/home/walkthrough-on-how-to-use-gnome-boxes)，并致力于为 Linux 用户提供高品质的<ruby> 桌面体验 <rt> desktop experience </rt></ruby>。
**Ubuntu 18.04** 是 Ubuntu 目前最新的 [<ruby> 长期支持版本 <rt> Long Term Support </rt></ruby>](http://www.linuxandubuntu.com/home/ubuntu-1804-codename-announced-bionic-beaver)（LTS），为用户提供 GNOME 桌面系统。**Fedora 28** 也提供 GNOME 桌面系统，但落实到具体的软件包管理方面，二者的桌面体验存在差异；在<ruby> 用户界面 <rt> User Interfaces </rt></ruby>方面也显然存在差异。
### 基本概念
不知你是否了解，虽然 Ubuntu 基于 Debian，但 Ubuntu 比 Debian 更早提供最新版本的软件。举个例子，当 Ubuntu 提供流行网页浏览器 Firefox Quantum 时，Debian 仍在提供 Firefox 的<ruby> 延期支持版 <rt> Extended Support Release </rt></ruby>（ESR）。
（LCTT 译注：从 2012 年 1 月开始，Firefox 进入快速版本期，每 6 周发布新的主线版本，每隔 7 个主线版本发布新的 ESR 版本。Firefox 57 的桌面版发布时被命名为 Firefox Quantum，同期的 ESR 版本与 Firefox 52 一同发布并基于 Firefox 48。参考 [Wiki: History\_of\_Firefox](https://en.wikipedia.org/wiki/History_of_Firefox)）
同样的情况也适用于 Fedora，它为终端用户提供前沿的软件，也被用作下一个稳定版本的 RHEL (Red Hat Enterprise Linux) 的测试平台。
### 桌面预览
Fedora 提供<ruby> 原汁原味的 <rt> vanilla </rt></ruby> GNOME 桌面体验；相比之下，Ubuntu 18.04 对 GNOME 做了若干方面的微调，以便长期以来的 Unity 用户可以平滑的过渡到 GNOME 桌面环境。
*为节省开发时间，Canonical （从 Ubuntu [17.10](http://www.linuxandubuntu.com/home/what-new-is-going-to-be-in-ubuntu-1704-zesty-zapus) 开始）已经决定放弃 Unity 并转向 GNOME 桌面，以便可以将更多精力投入到 IoT 领域。*
因此，在 Fedora 的桌面预览中，我们可以看到一个简洁的无图标桌面和一个自动隐藏的侧边栏，整体外观采用 GNOME 默认的 Adwaita 主题。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ubuntu-18-04-gnome_orig.jpg)
相比之下，Ubuntu 采用其经典的有图标桌面样式，左侧边栏用于模拟其传统的“<ruby> 程序坞 <rt> dock </rt></ruby>”，使用 Ubuntu Ambiance 主题定制化窗口，与其传统的（Unity 桌面）外观和体验基本一致。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ubuntu-gnome-18-04_orig.jpg)
虽然存在一定差异，但习惯使用其中一种桌面环境后切换到另外一种并不困难。毕竟二者设计时都充分考虑了简洁性和用户友好性，即使是新用户也不会对这两种 Linux 发行版感到不适应。
但外观或 UI 并不是决定用户选择哪一种 Linux 发行版的唯一因素，还有其它因素也会影响用户的选择。下面主要介绍两种 Linux 发行版在软件包管理相关方面的内容。
### 软件中心
Ubuntu 使用 dpkg（即 Debian Package Management）将软件分发给终端用户；Fedora 则使用 rpm（全称为 Red Hat Package Management）。它们都是 Linux 社区中非常流行的包管理系统，对应的命令行工具也都简单易用。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ubuntu-software-center_2_orig.jpg)
但在具体分发的软件方面，各个 Linux 发行版会有明显差异。Canonical 每 6 个月发布新版本的 Ubuntu，一般是在每年的 4 月和 10 月。对每个版本，开发者会维护一个开发计划；Ubuntu 新版本发布后，该版本就会进入<ruby> 冻结 <rt> freeze </rt></ruby>状态，即停止新软件的开发和测试。
相比之下，Fedora 也采用相似的 6 个月发布周期，看起来很像一种<ruby> 滚动更新 <rt> rolling release </rt></ruby>的 Linux 发行版（其实并不是这样）。与 Ubuntu 不同之处在于，（Fedora 中的）几乎所有软件包更新都很频繁，让用户有机会尝试最新版本的软件。但这样也导致软件 Bug 更频繁出现，给用户带来“不稳定性”，虽然还不至于导致系统不可用。
### 软件更新
我上面已经提到了 Ubuntu 版本的冻结状态。好吧，由于它对 Ubuntu 软件更新方式有着重要的影响，我再次提到这个状态：当 Ubuntu 新版本发布后，该版本的开发（这里是指测试新软件）就停止了。
*即将发布的下个版本的开发也随之开始，先后历经 “<ruby> 每日构建 <rt> daily build </rt></ruby>” 和 “<ruby> 测试版 <rt> beta release </rt></ruby>” 阶段，最后作为新版本发布给终端用户。*
在冻结状态下，Ubuntu 维护者不会在<ruby> 软件源 <rt> package repository </rt></ruby>中增加最新版软件，除非用于解决严重的安全问题。因此，Ubuntu 用户可用的软件更新更多涉及 Bug 修复而不是新特性，这样的好处在于系统可以保持稳定，不会扰乱用户的使用。
Fedora 试图为终端用户提供最新版本的软件，故用户的可用软件更新相比 Ubuntu 而言会更多涉及新特性。当然，开发者为了维持系统的稳定性，也采取了一系列措施。例如，在操作系统启动时，用户可以从最多三个<ruby> 可用内核 <rt> working kernel </rt></ruby>（最新内核处于最上方）中进行选择；当新内核无法启动时，用户可以回滚使用之前两个可用内核。
### Snaps 和 flatpak
它们都是新出现的酷炫工具，可以将软件发布到多个 Linux 发行版上。Ubuntu 提供 **snaps**，而 Fedora 则提供 **flatpak** 。二者之中 snaps 更加流行，更多流行软件或版权软件都在考虑上架 snap 商店。Flatpak 也在吸引关注，越来越多的软件上线该平台。
不幸的是，由于二者出现的时间都不久，很多人遇到“<ruby> 窗口主题不一致 <rt> window theme-breaking </rt></ruby>”问题并在网上表达不满。但由于二者都很易于使用，在二者之间切换并不是难事。
（LCTT 译注：按译者理解，由于二者都增加了一层安全隔离，读取系统主题方面会遇到问题；另外，似乎也有反馈 snap 专用主题无法及时应用于 snap 的问题）
### 应用对比
下面列出一些在 Ubuntu 和 Fedora 上共有的常见应用，然后在两个平台之间进行对比：
#### 计算器
Fedora 上的计算器程序启动速度更快。这是因为 Fedora 上的计算器程序是软件包形式安装的，而 Ubuntu 上的计算器程序则是 snap 版本。
#### 系统监视器
可能听上去比较书呆子气，但我认为观察计算机性能并杀掉令人讨厌的进程是必要且直观的。程序启动速度对比与计算器的结果一致，即 （软件包方式安装的）Fedora 版本快于（snap 形式提供的）Ubuntu 版本。
#### 帮助程序
我已经提到，（为便于长期以来的 Untiy 用户平滑切换到 GNOME），Ubuntu 提供的 GNOME 桌面环境是经过微调的版本。不幸的是，Ubuntu 开发者似乎忘记或忽略了对帮助程序的更新，用户阅读文档（入门视频）后会发现演示视频与真实环境有略微差异，这可能让人感到迷惑。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ubuntu-18-04-help-manual_orig.jpg)
### 结论
Ubuntu 和 Fedora 是两个主流的 Linux 发行版。两者都各自有一些华而不实的特性，因而新接触 Linux 的人很难抉择。我的建议是同时尝试二者，这样你在试用后可以发现哪个发行版提供的工具更适合你。
希望你阅读愉快，你可以在下方的评论区给出我漏掉的内容或你的建议。
---
via: <http://www.linuxandubuntu.com/home/ubuntu-1804-vs-fedora-28>
作者：[LinuxAndUbuntu](http://www.linuxandubuntu.com) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
将 Linux 终端会话录制成 SVG 动画
|
Sk
|
https://www.ostechnix.com/how-to-record-terminal-sessions-as-svg-animations-in-linux/
|
它是一款简单的命令行工具，使用 Python 语言编写，可以生成轻量级、外观整洁的动画，可以嵌入到网页项目中。
|
/data/attachment/album/201808/26/122348fzcxp6rr6pt16x19.png.thumb.jpg
|
/data/attachment/album/201808/26/122348fzcxp6rr6pt16x19.png
| true | false | true |
lujun9972
|
pinewall
|
wxy
| false |
[
"动画",
"SVG"
] |
分享
|
{
"viewnum": 6137,
"commentnum": 1,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "125.85.207.156",
"message": "很棒的功能",
"username": "来自重庆的 Chromium 74.0|Ubuntu 用户",
"date": "2020-03-19T09:30:14"
}
] |
[] |
它是一款简单的命令行工具，使用 Python 语言编写，可以生成轻量级、外观整洁的动画，可以嵌入到网页项目中。
| 2018-08-26T12:23:00 | 2018-08-26T12:23:00 | 9,953 |
/article-9953-1.html
|
录制终端会话可以满足我们不同类型的需求。通过录制终端会话，你可以完整记录你在终端中执行的操作，将其保存以供后续参考。通过录制终端会话，你还可以向青少年、学生或其它打算学习 Linux 的人展示各种 Linux 命令及其用例。值得庆幸的是，市面上已经有不少工具，可以帮助我们在类 Unix 操作系统下录制终端会话。我们已经介绍过一些可以帮助你录制终端会话的工具，可以在下面的链接中找到。
* [如何录制你在终端中的所作所为](https://www.ostechnix.com/record-everything-terminal/)
* [Asciinema – 录制终端会话并在网上分享](https://www.ostechnix.com/asciinema-record-terminal-sessions-share-web/)
今天，我们要介绍另一款录制终端操作的工具，名字叫做 **Termtosvg**。从名字可以看出，Termtosvg 将你的终端会话录制成一个单独的 SVG 动画。它是一款简单的命令行工具，使用 **Python** 语言编写，可以生成轻量级、外观整洁的动画，可以嵌入到网页项目中。Termtosvg 支持自定义<ruby> 色彩主题 <rt> color themes </rt></ruby>、终端 UI，还可以通过 [SVG 模板](https://nbedos.github.io/termtosvg/pages/templates.html)完成动画控制。它兼容 asciinema 录制格式，支持 GNU/Linux，Mac OS 和 BSD 等操作系统。
### 安装 Termtosvg
PIP 是一个面向 Python 语言编写的软件包的管理器，可以用于安装 Termtosvg。如果你没有安装 PIP，可以参考下面的指导：
* [如何使用 PIP 管理 Python 软件包](https://www.ostechnix.com/manage-python-packages-using-pip/)
安装 PIP 后，运行如下命令安装 Termtosvg 工具：
```
$ pip3 install --user termtosvg
```
此外，还要安装渲染终端屏幕所需的依赖包：
```
$ pip3 install pyte python-xlib svgwrite
```
安装完毕，我们接下来生成 SVG 格式的终端会话。
### 将 Linux 终端会话录制成 SVG 动画
使用 `termtosvg` 录制终端会话十分容易。打开终端窗口，运行如下命令即可开始录制：
```
$ termtosvg
```
**注意：** 如果 `termtosvg` 命令不可用，重启操作系统一次即可。
运行 `termtosvg` 命令后，可以看到如下命令输出：
```
Recording started, enter "exit" command or Control-D to end
```
你目前位于一个子 Shell 中，在这里可以像平常那样输入命令。你在终端中的所作所为都会被录制。
不妨随便输入一些命令：
```
$ mkdir mydirectory
$ cd mydirectory/
$ touch file.txt
$ cd ..
$ uname -a
```
操作完成后，使用组合键 `CTRL+D` 或者输入 `exit` 停止录制。录制结果将会保存在 `/tmp` 目录，（由于做了唯一性处理）文件名并不会重复。
现在，你可以在命令行运行命令，使用你的浏览器打开 SVG 文件：
```
$ firefox /tmp/termtosvg_ddkehjpu.svg
```
你也可以在（图形界面的）浏览器中直接打开这个 SVG 文件（ **File -> <SVG 文件路径>** ）。
我用 Firefox 浏览器打开的效果如下：
下面举例说明几种使用 Termtosvg 录制终端会话的方式。
我刚刚提到，Termtosvg 录制终端会话后默认保存成 `/tmp` 目录下的一个 SVG 动画文件。
但你可以指定 SVG 动画文件的文件名，例如 `animation.svg`；也可以指定一个存放路径，例如 `/home/sk/ostechnix/`。
```
$ termtosvg /home/sk/ostechnix/animation.svg
```
录制终端会话并使用特定模板进行渲染：
```
$ termtosvg -t ~/templates/my_template.svg
```
使用指定的<ruby> 屏幕参数 <rt> screen geometry </rt></ruby>录制终端会话：
```
$ termtosvg -g 80x24 animation.svg
```
使用 asciicast v2 格式录制终端会话：
```
$ termtosvg record recording.cast
```
将 asciicast 格式的录制结果渲染成 SVG 动画：
```
$ termtosvg render recording.cast animation.svg
```
欲了解更多细节，请参考 [**Termtosvg 手册**](https://github.com/nbedos/termtosvg/blob/develop/man/termtosvg.md)。
好了，本次分享就到这里，希望对你有帮助。更多精彩内容，敬请期待！
干杯！
---
via: <https://www.ostechnix.com/how-to-record-terminal-sessions-as-svg-animations-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux Shell 编程中定义和使用函数
|
Pradeep Kumar
|
https://www.linuxtechi.com/define-use-functions-linux-shell-script/
|
函数是一段可复用的代码。我们通常把重复的代码放进函数中并且在不同的地方去调用它。库是函数的集合。我们可以在库中定义经常使用的函数，这样其它脚本便可以不再重复代码而使用这些函数。
|
/data/attachment/album/201808/27/115014e99y39abn4r4krkf.jpg.thumb.jpg
|
/data/attachment/album/201808/27/115014e99y39abn4r4krkf.jpg
| true | false | true |
lujun9972
|
LuuMing
|
pityonline
| false |
[
"函数",
"bash",
"shell"
] |
技术
|
{
"viewnum": 11490,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
函数是一段可复用的代码。我们通常把重复的代码放进函数中并且在不同的地方去调用它。库是函数的集合。我们可以在库中定义经常使用的函数，这样其它脚本便可以不再重复代码而使用这些函数。
| 2018-08-27T11:50:00 | 2018-08-27T11:50:00 | 9,954 |
/article-9954-1.html
|
函数是一段可复用的代码。我们通常把重复的代码放进函数中并且在不同的地方去调用它。库是函数的集合。我们可以在库中定义经常使用的函数，这样其它脚本便可以不再重复代码而使用这些函数。
本文我们将讨论诸多关于函数的内容和一些使用技巧。为了方便演示，我将在 Ubuntu 系统上使用 **Bourne Again SHell (Bash)**。
### 调用函数
在 Shell 中调用函数和调用其它命令是一模一样的。例如，如果你的函数名称为 `my_func`，你可以在命令行中像下面这样执行它：
```
$ my_func
```
如果你的函数接收多个参数，那么可以像下面这样写（类似命令行参数的使用）：
```
$ my_func arg1 arg2 arg3
```
### 定义函数
我们可以用下面的语法去定义一个函数：
```
function function_name {
Body of function
}
```
函数的主体可以包含任何有效的命令、循环语句和其它函数或脚本。现在让我们创建一个简单的函数，它向屏幕上显示一些消息（注：直接在命令行里写）。
```
function print_msg {
echo "Hello, World"
}
```
现在，让我们执行这个函数：
```
$ print_msg
Hello, World
```
不出所料，这个函数在屏幕上显示了一些消息。
在上面的例子中，我们直接在终端里创建了一个函数。这个函数也可以保存到文件中。如下面的例子所示。
```
#!/bin/bash
function print_msg {
echo "Hello, World"
}
print_msg
```
我们已经在 `function.sh` 文件中定义了这个函数。现在让我们执行这个脚本：
```
$ chmod +x function.sh
$ ./function.sh
Hello, World
```
你可以看到，上面的输出和之前的是一模一样的。
### 更多函数用法
在上一小节中我们定义了一个非常简单的函数。然而在软件开发的过程中，我们需要更多高级的函数，它可以接收多个参数并且带有返回值。在这一小节中，我们将讨论这种函数。
#### 向函数传递参数
我们可以像调用其它命令那样给函数提供参数。我们可以在函数里使用美元 `$` 符号访问到这些参数。例如，`$1` 表示第一个参数，`$2` 代表第二个参数，以此类推。
让我们修改下之前的函数，让它以参数的形式接收信息。修改后的函数就像这样：
```
function print_msg {
echo "Hello $1"
}
```
在上面的函数中我们使用 `$1` 符号访问第一个参数。让我们执行这个函数：
```
$ print_msg "LinuxTechi"
```
执行完后，生成如下信息：
```
Hello LinuxTechi
```
#### 从函数中返回数值
跟其它编程语言一样，Bash 提供了返回语句让我们可以向调用者返回一些数值。让我们举例说明：
```
function func_return_value {
return 10
}
```
上面的函数向调用者返回 `10`。让我们执行这个函数：
```
$ func_return_value
$ echo "Value returned by function is: $?"
```
当你执行完，将会产生如下的输出结果：
```
Value returned by function is: 10
```
**提示**：在 Bash 中使用 `$?` 去获取函数的返回值。
### 函数技巧
目前我们已经对 Bash 中的函数有了一些了解。现在让我们创建一些非常有用的 Bash 函数，它们可以让我们的生活变得更加轻松。
#### Logger
让我们创建一个 `logger` 函数，它可以输出带有日期和时间的 log 信息。
```
function log_msg {
echo "[`date '+ %F %T'` ]: $@"
}
```
执行这个函数：
```
$ log_msg "This is sample log message"
```
执行完，就会生成如下信息：
```
[ 2018-08-16 19:56:34 ]: This is sample log message
```
#### 显示系统信息
让我们创建一个显示 GNU/Linux 信息的函数
```
function system_info {
echo "### OS information ###"
lsb_release -a
echo
echo "### Processor information ###"
processor=`grep -wc "processor" /proc/cpuinfo`
model=`grep -w "model name" /proc/cpuinfo | awk -F: '{print $2}'`
echo "Processor = $processor"
echo "Model = $model"
echo
echo "### Memory information ###"
total=`grep -w "MemTotal" /proc/meminfo | awk '{print $2}'`
free=`grep -w "MemFree" /proc/meminfo | awk '{print $2}'`
echo "Total memory: $total kB"
echo "Free memory : $free kB"
}
```
执行完后会生成以下信息：
```
### OS information ###
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 18.04.1 LTS
Release: 18.04
Codename: bionic
### Processor information ###
Processor = 1
Model = Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
### Memory information ###
Total memory: 4015648 kB
Free memory : 2915428 kB
```
#### 在当前目录下查找文件或者目录
下面的函数从当前目录下查找文件或者目录：
```
function search {
find . -name $1
}
```
让我们使用下面的命令查找 `dir4` 这个目录：
```
$ search dir4
```
当你执行完命令后，将会产生如下输出：
```
./dir1/dir2/dir3/dir4
```
#### 数字时钟
下面的函数在终端里创建了一个简单的数字时钟：
```
function digital_clock {
clear
while [ 1 ]
do
date +'%T'
sleep 1
clear
done
}
```
### 函数库
库是函数的集合。将函数定义在文件里并在当前环境中导入那个文件，这样可以创建函数库。
假设我们已经在 `utils.sh` 中定义好了所有函数，接着在当前的环境下使用下面的命令导入函数：
```
$ source utils.sh
```
之后你就可以像调用其它 Bash 命令那样执行库中任何的函数了。
### 总结
本文我们讨论了诸多可以提升效率的实用技巧。我希望这篇文章能够启发你去创造自己的技巧。
---
via: <https://www.linuxtechi.com/define-use-functions-linux-shell-script/>
作者：[Pradeep Kumar](http://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LuuMing](https://github.com/LuuMing) 校对：[pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
尝试、学习、修改：新 IT 领导者的代码
|
Jim Whitehurst
|
https://opensource.com/open-organization/18/3/try-learn-modify
|
随着创新步伐的增加, 长期规划变得越来越困难。让我们重新思考一下我们对变化的反应方式。
|
/data/attachment/album/201808/27/121206f6h6dz66uv7ifhsn.png.thumb.jpg
|
/data/attachment/album/201808/27/121206f6h6dz66uv7ifhsn.png
| true | false | true |
MjSeven
|
wxy
| false |
[
"开放式组织"
] |
观点
|
{
"viewnum": 3384,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
随着创新步伐的增加, 长期规划变得越来越困难。让我们重新思考一下我们对变化的反应方式。
| 2018-08-27T12:12:00 | 2018-08-27T12:12:00 | 9,955 |
/article-9955-1.html
|
>
> 随着创新步伐的增加, 长期规划变得越来越困难。让我们重新思考一下我们对变化的反应方式。
>
>
>
几乎每一天，新的技术发展都可能会动摇那些甚至最复杂、最完善的商业计划。组织经常发现自己需要不断努力适应新的环境，这导致了他们对未来规划的转变。
根据 CompTIA 2017 年的[研究](https://www.cio.com/article/3246027/enterprise-architecture/the-death-of-long-term-it-planning.html?upd=1515780110970)，目前只有 34% 的公司正在制定超过 12 个月的 IT 架构计划。从长期计划转变的一个原因是：商业环境变化如此之快，以至于几乎不可能进一步规划未来。[CIO.com 说道](https://www.cio.com/article/3246027/enterprise-architecture/the-death-of-long-term-it-planning.html?upd=1515780110970)，“如果你的公司正视图制定一项将持续五到十年的计划，那就忘了它。”
我听过来自世界各地无数客户和合作伙伴的类似声明：技术创新正以一种前所未有的速度发生着。
其结果是长期规划已不复存在。如果我们要在这个新世界取得成功，我们需要以不同的方式思考我们运营组织的方式。
### 计划是怎么死的
正如我在《<ruby> 开放式组织 <rt> The Open Organization </rt></ruby>》中写的那样，传统经营组织针对工业经济进行了优化。他们采用等级结构和严格规定的流程，以实现地位竞争优势。要取得成功，他们必须确定他们想要实现的战略地位。然后，他们必须制定并规划实现目标的计划，并以最有效的方式执行这些计划，通过协调活动和推动合规性。
管理层的职责是优化这一过程：计划、规定、执行。包括：让我们想象一个有竞争力的优势地位；让我们来配置组织以最终达成目标；然后让我们通过确保组织的所有方面都遵守规定来推动执行。这就是我所说的“机械管理”，对于不同时期来说它都是一个出色的解决方案。
在当今动荡不定的世界中，我们预测和定义战略位置的能力正在下降，因为变化的速度，新变量的引入速度正在加速。传统的、长期的、战略性规划和执行不像以前那么有效。
如果长期规划变得如此困难，那么规定必要的行为就更具有挑战性。并且衡量对计划的合规性几乎是不可能的。
这一切都极大地影响了人们的工作方式。与过去传统经营组织中的工人不同，他们为自己能够重复行动而感到自豪，几乎没有变化和舒适的确定性 —— 今天的工人在充满模糊性的环境中运作。他们的工作需要更大的创造力、直觉和批判性判断 —— 更多的需要背离过去的“常规”，以适应当今的新情况。
以这种新方式工作对于价值创造变得更加重要。我们的管理系统必须专注于构建结构，系统和流程，以帮助创建积极主动的工人，他们能够以快速和敏捷的方式进行创新和行动。
我们需要提出一个不同的解决方案来优化组织，以适应不同的经济时代，从自下而上而不是自上而下开始。我们需要替换过去的三步骤 —— 计划、规定、执行，以一种更适应当今动荡天气的方法来取得成功 —— 尝试、学习、修改。
### 尝试、学习、修改
因为环境变化如此之快，而且几乎没有任何预警，并且因为我们需要采取的步骤不再提前计划，我们需要培养鼓励创造性尝试和错误的环境，而不是坚持对五年计划的忠诚。以下是以这种方式开始工作的一些暗示：
* **更短的计划周期（尝试）。** 管理者需要考虑的是他们可以快速尝试的短期实验，而不是在长期战略方向上苦恼。他们应该寻求方法来帮助他们的团队承担计算风险，并利用他们掌握的数据来对最有利的路径做出最好的猜测。他们可以通过降低开销和让团队自由快速尝试新方法来做到这一点。
* **更高的失败容忍度（学习）。** 更多的实验频率意味着更大的失败机会。与传统组织相比，富有创造力和有弹性的组织[对失败的容忍度要高得多](https://opensource.com/open-organization/16/12/building-culture-innovation-your-organization)。管理者应将失败视为学习的机会，在他们的团队正在运行的测试中收集反馈的时刻。
* **更具适应性的结构（修改）。** 能够轻松修改组织结构和战略方向，以及在条件需要时愿意这样做，是确保组织能够根据快速变化的环境条件发展的关键。管理者不能再拘泥于任何想法，因为这个想法证明自己对实现短期目标很有用。
如果长期计划已经消亡，那么就可以进行长期的短期实验。尝试，学习和修改，这是在不确定时期前进的最佳途径。
[订阅我们的每周实事通讯](https://opensource.com/open-organization/resources/newsletter)以了解有关开源组织的更多信息。
---
via: <https://opensource.com/open-organization/18/3/try-learn-modify>
作者：[Jim Whitehurst](https://opensource.com/users/remyd)
译者：[MjSeven](https://github.com/MjSeven)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
L1 终端错误漏洞（L1TF）如何影响 Linux 系统
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3298157/linux/linux-and-l1tf.html
|
L1 终端错误（L1TF）影响英特尔处理器和 Linux 操作系统。让我们了解一下这个漏洞是什么，以及 Linux 用户需要为它做点什么。
|
/data/attachment/album/201808/27/123607kcc0z80vz8qc7fjp.jpg.thumb.jpg
|
/data/attachment/album/201808/27/123607kcc0z80vz8qc7fjp.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"L1TF",
"漏洞",
"CPU"
] |
新闻
|
{
"viewnum": 6010,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
L1 终端错误（L1TF）影响英特尔处理器和 Linux 操作系统。让我们了解一下这个漏洞是什么，以及 Linux 用户需要为它做点什么。
| 2018-08-27T12:36:04 | 2018-08-27T12:36:04 | 9,956 |
/article-9956-1.html
|
>
> L1 终端错误（L1TF）影响英特尔处理器和 Linux 操作系统。让我们了解一下这个漏洞是什么，以及 Linux 用户需要为它做点什么。
>
>
>
昨天（LCTT 译注：本文发表于 2018/8/15）在英特尔、微软和红帽的安全建议中宣布，一个新发现的漏洞英特尔处理器（还有 Linux）的漏洞称为 L1TF 或 “<ruby> L1 终端错误 <rt> L1 Terminal Fault </rt></ruby>”，引起了 Linux 用户和管理员的注意。究竟什么是这个漏洞，谁应该担心它？
### L1TF、 L1 Terminal Fault 和 Foreshadow
处理器漏洞被称作 L1TF、L1 Terminal Fault 和 Foreshadow。研究人员在 1 月份发现了这个问题并向英特尔报告称其为 “Foreshadow”。它类似于过去发现的漏洞（例如 Spectre）。
此漏洞是特定于英特尔的。其他处理器不受影响。与其他一些漏洞一样，它之所以存在，是因为设计时为了优化内核处理速度，但允许其他进程访问数据。
**[另请阅读：[22 个必要的 Linux 安全命令](https://www.networkworld.com/article/3272286/open-source-tools/22-essential-security-commands-for-linux.html)]**
已为此问题分配了三个 CVE：
* CVE-2018-3615：英特尔<ruby> 软件保护扩展 <rt> Software Guard Extension </rt></ruby>（英特尔 SGX）
* CVE-2018-3620：操作系统和<ruby> 系统管理模式 <rt> ystem Management Mode </rt></ruby>（SMM）
* CVE-2018-3646：虚拟化的影响
英特尔发言人就此问题发表了这一声明：
>
> “L1 Terminal Fault 通过今年早些时候发布的微代码更新得到解决，再加上从今天开始提供的操作系统和虚拟机管理程序软件的相应更新。我们在网上提供了更多信息，并继续鼓励每个人更新操作系统，因为这是得到保护的最佳方式之一。我们要感谢 imec-DistriNet、KU Leuven、以色列理工学院，密歇根大学，阿德莱德大学和 Data61 的研究人员以及我们的行业合作伙伴，他们帮助我们识别和解决了这个问题。“
>
>
>
### L1TF 会影响你的 Linux 系统吗？
简短的回答是“可能不会”。如果你因为在今年 1 月爆出的 [Spectre 和 Meltdown 漏洞](https://www.networkworld.com/article/3245813/security/meltdown-and-spectre-exploits-cutting-through-the-fud.html)修补过系统，那你应该是安全的。与 Spectre 和 Meltdown 一样，英特尔声称真实世界中还没有系统受到影响的报告或者检测到。他们还表示，这些变化不太可能在单个系统上产生明显的性能影响，但它们可能对使用虚拟化操作系统的数据中心产生大的影响。
即使如此，仍然推荐频繁地打补丁。要检查你当前的内核版本，使用 `uname -r` 命令：
```
$ uname -r
4.18.0-041800-generic
```
### 更多资源
请查看如下资源以了解 L1TF 的更多细节，以及为什么会出现这个漏洞：
* [L1TF explained in ~3 minutes (Red Hat)](https://www.youtube.com/watch?v=kBOsVt0iXE4&feature=youtu.be)
* [L1TF explained in under 11 minutes (Red Hat)](https://www.youtube.com/watch?v=kqg8_KH2OIQ)
* [Technical deep dive](https://www.redhat.com/en/blog/deeper-look-l1-terminal-fault-aka-foreshadow)
* [Red Hat explanation of L1TF](https://access.redhat.com/security/vulnerabilities/L1TF)
* [Ubuntu updates for L1TF](https://blog.ubuntu.com/2018/08/14/ubuntu-updates-for-l1-terminal-fault-vulnerabilities)
---
via: <https://www.networkworld.com/article/3298157/linux/linux-and-l1tf.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/)
选题：[lujun9972](https://github.com/lujun9972)
译者：[geekpi](https://github.com/geekpi)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Fedora 下的图像创建程序
|
Ryan Lerch
|
https://fedoramagazine.org/image-creation-applications-fedora/
|
Fedora 有很多程序可以帮助你的创造力。从数字绘图、矢量到像素艺术，每个人都可以在这个周末发挥创意。
|
/data/attachment/album/201808/27/200911uu88fccccf8c4tfq.png.thumb.jpg
|
/data/attachment/album/201808/27/200911uu88fccccf8c4tfq.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Krita",
"Inkscape"
] |
分享
|
{
"viewnum": 4970,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Fedora 有很多程序可以帮助你的创造力。从数字绘图、矢量到像素艺术，每个人都可以在这个周末发挥创意。
| 2018-08-27T20:08:00 | 2018-08-27T20:08:00 | 9,957 |
/article-9957-1.html
|
有了创意吗？Fedora 有很多程序可以帮助你的创造力。从数字绘图、矢量到像素艺术，每个人都可以在这个周末发挥创意。本文重点介绍了 Fedora 下创建很棒图像的程序。
### 矢量图形：Inkscape
[Inkscape](http://inkscape.org) 是一个众所周知的、受人喜爱的开源矢量图形编辑器。SVG 是 Inkscape 的主要文件格式，因此你所有的图形都可以任意伸缩！Inkscape 已存在多年，所以有一个坚实的社区和用于入门的[大量教程和其他资源](https://inkscape.org/en/learn/tutorials/)。
作为矢量图形编辑器，Inkscape 更适合于简单的插图（例如简单的漫画风格）。然而，使用矢量模糊，一些艺术家创造了一些[令人惊奇的矢量图](https://inkscape.org/en/gallery/)。
从 Fedora Workstation 中的软件应用安装 Inkscape，或在终端中使用以下命令：
```
sudo dnf install inkscape
```
### 数字绘图：Krita 和 Mypaint
[Krita](https://krita.org/en/) 是一个流行的图像创建程序，用于数字绘图、光栅插图和纹理。此外，Krita 是一个活跃的项目，拥有一个充满活力的社区 —— 所以[有用于入门的很多教程](https://docs.krita.org/en/)。Krita 有多个画笔引擎、带有弹出调色板的 UI、用于创建无缝图案的环绕模式、滤镜、图层等等。
从 Fedora Workstation 中的软件应用安装 Krita，或在终端中使用以下命令：
```
sudo dnf install krita
```
[Mypaint](http://mypaint.org/about/) 是另一款适用于 Fedora 令人惊奇的数字绘图程序。像 Krita 一样，它有多个画笔和使用图层的能力。
从 Fedora Workstation 中的软件应用安装 Mypaint，或在终端中使用以下命令：
```
sudo dnf install mypaint
```
### 像素艺术：Libresprite
[Libresprite](https://github.com/LibreSprite/LibreSprite) 是一个专为创建像素艺术和像素动画而设计的程序。它支持一系列颜色模式，并可导出为多种格式（包括动画 GIF）。此外，Libresprite 还有用于创建像素艺术的绘图工具：多边形工具、轮廓和着色工具。
Libresprite 可从 Flathub 应用仓库下载。要安装，只需[启用 Flathub 作为软件源](https://fedoramagazine.org/install-flathub-apps-fedora/)，然后通过软件应用进行安装。
---
via: <https://fedoramagazine.org/image-creation-applications-fedora/>
作者：[Ryan Lerch](https://fedoramagazine.org/introducing-flatpak/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
开源网络方面的职位：创新与机遇的温床
|
Brandon Wick
|
https://www.linux.com/blog/os-jobs-report/2018/7/open-source-networking-jobs-hotbed-innovation-and-opportunities
|
诸如容器、边缘计算这样的技术焦点领域大红大紫，对在这一领域能够整合、协作、创新的开发者和系统管理员们的需求在日益增进。
|
/data/attachment/album/201808/27/203802l9jmxh99xhm77hhm.jpg.thumb.jpg
|
/data/attachment/album/201808/27/203802l9jmxh99xhm77hhm.jpg
| true | false | true |
lujun9972
|
LuuMing
|
wxy
| false |
[
"职位"
] |
观点
|
{
"viewnum": 3428,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
诸如容器、边缘计算这样的技术焦点领域大红大紫，对在这一领域能够整合、协作、创新的开发者和系统管理员们的需求在日益增进。
| 2018-08-27T20:37:58 | 2018-08-27T20:37:58 | 9,958 |
/article-9958-1.html
|
>
> 诸如容器、边缘计算这样的技术焦点领域大红大紫，对在这一领域能够整合、协作、创新的开发者和系统管理员们的需求在日益增进。
>
>
>
随着全球经济更加靠近数字化未来，每个垂直行业的公司和组织都在紧抓如何进一步在业务与运营上整合与部署技术。虽然 IT 企业在很大程度上遥遥领先，但是他们的经验与教训已经应用在了各行各业。尽管全国失业率为 4.1%，但整个科技专业人员的整体的失业率在 4 月份为 1.9%，开源工作的未来看起来尤其光明。我在开源网络领域工作，并且目睹着创新和机遇正在改变世界交流的方式。
它曾经是个发展缓慢的行业，现在由网络运营商、供应商、系统集成商和开发者所组成的网络生态系统正在采用开源软件，并且正在向商用硬件上运行的虚拟化和软件定义网络上转移。事实上，接近 70% 的全球移动用户由[低频网络](https://www.lfnetworking.org/)运营商成员所占据。该网络运营商成员致力于协调构成开放网络栈和相邻技术的项目。
### 技能需求
这一领域的开发者和系统管理员采用云原生和 DevOps 的方法开发新的使用案例，应对最紧迫的行业挑战。诸如容器、边缘计算等焦点领域大红大紫，并且在这一领域能够整合、协作、创新的开发者和系统管理员们的需求在日益增进。
开源软件与 Linux 使这一切成为可能，根据最近出版的 [2018开源软件工作报告](https://www.linuxfoundation.org/publications/2018/06/open-source-jobs-report-2018/)，高达 80% 的招聘经理寻找会 Linux 技能的应聘者，**而 46% 希望在网络领域招聘人才，可以说“网络技术”在他们的招聘决策中起到了至关重要的作用。**
开发人员相当抢手，72% 的招聘经理都在找他们，其次是 DevOps 开发者（59%），工程师（57%）和系统管理员（49%）。报告同时指出，对容器技能需求的惊人的增长符合我们在网络领域所见到的，即云本地虚拟功能（CNF）的创建和持续集成／持续部署方式的激增，就如在 OPNFV 中的 [XCI 倡议](https://docs.opnfv.org/en/latest/submodules/releng-xci/docs/xci-overview.html) 一样。
### 开始吧
对于求职者来说，好消息是有着大量的关于开源软件的内容，包括免费的 [Linux 入门课程](https://www.edx.org/course/introduction-linux-linuxfoundationx-lfs101x-1)。好的工作需要有多项证书，因此我鼓励你探索更多领域，去寻求培训的机会。计算机网络方面，在 [OPNFV](https://training.linuxfoundation.org/training/opnfv-fundamentals/) 上查看最新的培训课程或者是 [ONAP](https://training.linuxfoundation.org/training/onap-fundamentals/) 项目，也可以选择这门[开源网络技术简介](https://www.edx.org/course/introduction-to-software-defined-networking-technologies)课程。
如果你还没有做好这些，下载 [2018 开源软件工作报告](https://www.linuxfoundation.org/publications/2018/06/open-source-jobs-report-2018/) 以获得更多见解，在广阔的开放源码技术世界中规划你的课程，去寻找另一边等待你的令人兴奋的职业！
点击这里[下载完整的开源软件工作报告](https://www.linuxfoundation.org/publications/open-source-jobs-report-2018/)并且[了解更多关于 Linux 的认证](https://training.linuxfoundation.org/certification)。
---
via: <https://www.linux.com/blog/os-jobs-report/2018/7/open-source-networking-jobs-hotbed-innovation-and-opportunities>
作者：[Brandon Wick](https://www.linux.com/users/brandon-wick) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LuuMing](https://github.com/LuuMing) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
逐层拼接云原生栈
|
Zoe Allen
|
https://www.packet.net/blog/splicing-the-cloud-native-stack/
|
看着我们在纽约的办公大楼，我们发现了一种观察不断变化的云原生领域的完美方式。
|
/data/attachment/album/201808/29/002431d6v5wbssivbi4mvr.jpg.thumb.jpg
|
/data/attachment/album/201808/29/002431d6v5wbssivbi4mvr.jpg
| true | false | true |
lujun9972
|
qhwdw
|
wxy, pityonline
| true |
[
"云计算"
] |
观点
|
{
"viewnum": 6580,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
看着我们在纽约的办公大楼，我们发现了一种观察不断变化的云原生领域的完美方式。
| 2018-08-29T00:26:54 | 2018-08-29T00:26:54 | 9,959 |
/article-9959-1.html
|
>
> 看着我们在纽约的办公大楼，我们发现了一种观察不断变化的云原生领域的完美方式。
>
>
>
在 Packet，我们的工作价值（<ruby> 基础设施 <rt> infrastructure </rt></ruby>自动化）是非常基础的。因此，我们花费大量的时间来研究我们之上所有生态系统中的参与者和趋势 —— 以及之下的极少数！
当你在任何生态系统的汪洋大海中徜徉时，很容易困惑或迷失方向。我知道这是事实，因为当我去年进入 Packet 工作时，从 Bryn Mawr 获得的英语学位，并没有让我完全得到一个 [Kubernetes](https://kubernetes.io/) 的认证。:)
由于它超快的演进和巨大的影响，云原生生态系统打破了先例。似乎每眨一次眼睛，之前全新的技术（更不用说所有相关的理念了）就变得有意义……或至少有趣了。和其他许多人一样，我依据无处不在的 [CNCF](https://www.cncf.io/) 的 “[云原生蓝图](https://landscape.cncf.io/landscape=cloud)” 作为我去了解这个空间的参考标准。尽管如此，如果有一个定义这个生态系统的元素，那它一定是贡献和引领它们的人。
所以，在 12 月份一个很冷的下午，当我们走回办公室时，我们偶然发现了一个给投资人解释“云原生”的创新方式，当我们谈到从 [Aporeto](https://www.aporeto.com/) 中区分 [Cilium](https://cilium.io/) 的细微差别时，以及为什么从 [CoreDNS](https://coredns.io/) 和 [Spiffe](https://spiffe.io/) 到 [Digital Rebar](http://rebar.digital/) 和 [Fission](https://fission.io/) 的所有这些都这么有趣时，他的眼里充满了兴趣。
在新世贸中心的影子里向我们位于 13 层的狭窄办公室望去，我们突然想到一个把我们带到那个神奇世界的好主意：为什么不把它画出来呢？（LCTT 译注：“rabbit hole” 有多种含义，此处采用“爱丽丝梦游仙境”中的“兔子洞”含义。）
于是，我们开始了把云原生栈逐层拼接起来的旅程。让我们一起探索它，给你一个“仅限今日有效”的福利。（LCTT 译注：意即云原生领域变化很快，可能本文/本图中所述很快过时。）
[查看高清大图](https://www.dropbox.com/s/ujxk3mw6qyhmway/Packet_Cloud_Native_Building_Stack.jpg?dl=0)（25Mb）或给我们发邮件索取副本。
### 从最底层开始
当我们开始下笔的时候，我们希望首先亮出的是我们每天都在打交道的那一部分：硬件，但我们知道那对用户却是基本上不可见的。就像任何投资于下一个伟大的（通常是私有的）东西的秘密实验室一样，我们认为地下室是其最好的地点。
从大家公认的像 Intel、AMD 和华为（传言他们雇佣的工程师接近 80000 名）这样的巨头，到像 [Mellanox](http://www.mellanox.com/) 这样的细分市场参与者，硬件生态系统现在非常火。事实上，随着数十亿美元投入去攻克新的 offload（LCTT 译注：offload 泛指以前由软件及 CPU 来完成的工作，现在通过硬件来完成，以提升速度并降低 CPU 负载的做法）、GPU、定制协处理器，我们可能正在进入硬件的黄金时代。
著名的软件先驱[艾伦·凯](https://en.wikipedia.org/wiki/Alan_Kay)（Alan Kay）在 25 年前说过：“真正认真对待软件的人应该自己创造硬件”。说得不错，Alan！
### 云即资本
就像我们的 CEO Zac Smith 多次跟我说的：一切都是钱的事。不仅要制造它，还要消费它！在云中，数十亿美元的投入才能让数据中心出现计算机，这样才能让开发者消费它。换句话说（根本没云，它只是别人的电脑而已）：
我们认为，对于“银行”（即能让云运转起来的借款人或投资人）来说最好的位置就是一楼。因此我们将大堂改造成银行家的咖啡馆，以便为所有的创业者提供幸运之轮。
### 连通和动力
如果金钱是润滑油，那么消耗大量燃料的引擎就是数据中心供应商和连接它们的网络。我们称他们为“连通”和“动力”。
从像 [Equinix](https://www.equinix.com/) 这样处于核心地位的接入商的和像 [Vapor.io](https://www.vapor.io/) 这样的接入新贵，到 [Verizon](https://www.verizon.com/)、[Crown Castle](http://www.crowncastle.com/) 和其它接入商铺设在地下（或海底）的“管道”，这是我们所有的栈都依赖但很少有人能看到的一部分。
因为我们花费大量的时间去研究数据中心和连通性，需要注意的一件事情是，这一部分的变化非常快，尤其是在 5G 正式商用时，某些负载开始不再那么依赖中心化的基础设施了。
边缘计算即将到来！:-)
### 嗨，它就是基础设施！
居于“连通”和“动力”之上的这一层，我们爱称为“处理器层”。这是奇迹发生的地方 —— 我们将来自下层的创新和实物投资转变成一个 API 终端的某些东西。
由于这是纽约的一个大楼，我们让在这里的云供应商处于纽约的中心。这就是为什么你会看到（[Digital Ocean](https://www.digitalocean.com/) 系的）鲨鱼 Sammy 和对 “meet me” 房间里面的 Google 标志的致意的原因了。
正如你所见，这个场景是非常写实的。它是由多层机架堆叠起来的。尽管我们爱 EWR1 的设备经理（Michael Pedrazzini），我们努力去尽可能减少这种体力劳动。毕竟布线专业的博士学位是很难拿到的。
### 供给
再上一层，在基础设施层之上是供给层。这是我们最喜欢的地方之一，它以前被我们称为<ruby> 配置管理 <rt> config management </rt></ruby>。但是现在到处都是一开始就是<ruby> 不可变基础设施 <rt> immutable infrastructure </rt></ruby>和自动化：[Terraform](https://www.terraform.io/)、[Ansible](https://www.ansible.com/)、[Quay.io](https://quay.io/) 等等类似的东西。你可以看出软件是按它的方式来工作的，对吗？
Kelsey Hightower 最近写道“呆在无聊的基础设施中是一个让人兴奋的时刻”，我不认为这说的是物理部分（虽然我们认为它非常让人兴奋），但是由于软件持续侵入到栈的所有层，那必将是一个疯狂的旅程。
### 操作系统
供应就绪后，我们来到操作系统层。在这里你可以看到我们打趣一些我们最喜欢的同事：注意上面 Brian Redbeard 那超众的瑜珈姿势。:)
Packet 为客户提供了 11 种主要的操作系统可供选择，包括一些你在图中看到的：[Ubuntu](https://www.ubuntu.com/)、[CoreOS](https://coreos.com/)、[FreeBSD](https://www.freebsd.org/)、[Suse](https://www.suse.com/)、和各种 [Red Hat](https://www.redhat.com/) 系的发行版。我们看到越来越多的人们在这一层上加入了他们自己的看法：从定制内核和用于不可变部署的<ruby> 黄金镜像 <rt> golden images </rt></ruby>（LCCT 注：golden image 指定型的镜像或模板，一般是经过一些定制，并做快照和版本控制，由此可拷贝出大量与此镜像一致的开发、测试或部署环境，也有人称作 master image），到像 [NixOS](https://nixos.org/) 和 [LinuxKit](https://github.com/linuxkit/linuxkit) 这样的项目。
### 运行时
为了有趣些，我们将<ruby> 运行时 <rt> runtime </rt></ruby>放在了体育馆内，并为 CoreOS 赞助的 [rkt](https://coreos.com/rkt/) 和 [Docker](https://www.docker.com/) 的容器化举行了一次比赛。而无论如何赢家都是 CNCF！
我们认为快速演进的存储生态系统应该是一些可上锁的储物柜。关于存储部分有趣的地方在于许多的新玩家尝试去解决持久性的挑战问题，以及性能和灵活性问题。就像他们说的：存储很简单。
### 编排
在过去的这一年里，编排层全是 Kubernetes 了，因此我们选取了其中一位著名的布道者（Kelsey Hightower），并在这个古怪的会议场景中给他一个特写。在我们的团队中有一些 [Nomad](https://www.nomadproject.io/)（LCTT 译注：一个管理机器集群并在集群上运行应用程序的工具）的忠实粉丝，并且如果抛开 Docker 和它的工具集的影响，就无从谈起云原生。
虽然负载编排应用程序在我们栈中的地位非常高，我们看到的各种各样的证据表明，这些强大的工具开始去深入到栈中，以帮助用户利用 GPU 和其它特定硬件的优势。请继续关注 —— 我们正处于容器化革命的早期阶段！
### 平台
这是栈中我们喜欢的层之一，因为每个平台都有如此多的工具帮助用户去完成他们想要做的事情（顺便说一下，不是去运行容器，而是运行应用程序）。从 [Rancher](https://rancher.com/) 和 [Kontena](https://kontena.io/)，到 [Tectonic](https://coreos.com/tectonic/) 和 [Redshift](https://aws.amazon.com/redshift/) 都是像 [Cycle.io](https://cycle.io/) 和 [Flynn.io](https://flynn.io/) 一样是完全不同的方法 —— 我们看到这些项目如何以不同的方式为用户提供服务，总是激动不已。
关键点：这些平台是帮助用户转化云原生生态系统中各种各样的快速变化的部分。很高兴能看到他们各自带来的东西！
### 安全
当说到安全时，今年真是很忙的一年！我们尝试去展示一些很著名的攻击，并说明随着工作负载变得更加分散和更加可迁移（当然，同时攻击者也变得更加智能），这些各式各样的工具是如何去帮助保护我们的。
我们看到一个用于不可信环境（如 Aporeto）和低级安全（Cilium）的强大动作，以及尝试在网络级别上的像 [Tigera](https://www.tigera.io/) 这样的可信方法。不管你的方法如何，记住这一点：安全无止境。:0
### 应用程序
如何去表示海量的、无限的应用程序生态系统？在这个案例中，很容易：我们在纽约，选我们最喜欢的。;) 从 [Postgres](https://www.postgresql.org/) “房间里的大象” 和 [Timescale](https://www.timescale.com/) 时钟，到鬼鬼祟祟的 [ScyllaDB](https://www.scylladb.com/) 垃圾桶和那个悠闲的 [Travis](https://travis-ci.com/) 哥们 —— 我们把这个片子拼到一起很有趣。
让我们感到很惊奇的一件事情是：很少有人注意到那个复印屁股的家伙。我想现在复印机已经不常见了吧？
### 可观测性
由于我们的工作负载开始到处移动，规模也越来越大，这里没有一件事情能够像一个非常好用的 [Grafana](https://grafana.com/) 仪表盘、或方便的 [Datadog](https://www.datadoghq.com/) 代理让人更加欣慰了。由于复杂度的提升，[SRE](https://en.wikipedia.org/wiki/Site_Reliability_Engineering) 时代开始越来越多地依赖监控告警和其它智能事件去帮我们感知发生的事件，出现越来越多的自我修复的基础设施和应用程序。
在未来的几个月或几年中，我们将看到什么样的面孔进入这一领域……或许是一些人工智能、区块链、机器学习支撑的仪表盘？:-)
### 流量管理
人们往往认为互联网“只是能工作而已”，但事实上，我们很惊讶于它居然能如此工作。我的意思是，就这些大规模的、不同的网络间的松散连接 —— 你不是在开玩笑吧？
能够把所有的这些独立的网络拼接到一起的一个原因是流量管理、DNS 和类似的东西。随着规模越来越大，这些让互联网变得更快、更安全、同时更具弹性。我们尤其高兴的是看到像 [Fly.io](https://fly.io/) 和 [NS1](https://ns1.com/) 这样的新贵与优秀的老牌玩家进行竞争，最后的结果是整个生态系统都得以提升。让竞争来的更激烈吧！
### 用户
如果没有非常棒的用户，技术栈还有什么用呢？确实，他们享受了大量的创新，但在云原生的世界里，他们所做的远不止消费这么简单：他们也创造并贡献了很多。从像 Kubernetes 这样的大量的贡献者到越来越多的（但同样重要）更多方面，而我们都是其中的非常棒的一份子。
在我们屋顶上有许多悠闲的用户，比如 [Ticketmaster](https://www.ticketmaster.com/) 和[《纽约时报》](https://www.nytimes.com/)，而不仅仅是新贵：这些组织拥抱了部署和管理应用程序的方法的变革，并且他们的用户正在享受变革带来的回报。
### 同样重要的，成熟的监管！
在以前的生态系统中，基金会扮演了一个非常被动的“幕后”角色。而 CNCF 不是！他们的目标（构建一个健壮的云原生生态系统），勇立潮流之先 —— 他们不仅已迎头赶上还一路领先。
从坚实的治理和经过深思熟虑的项目组，到提出像 CNCF 这样的蓝图，CNCF 横跨云 CI、Kubernetes 认证、和讲师团 —— CNCF 已不再是 “仅仅” 受欢迎的 [KubeCon + CloudNativeCon](https://www.cncf.io/community/kubecon-cloudnativecon-events/) 了。
---
via: <https://www.packet.net/blog/splicing-the-cloud-native-stack/>
作者：[Zoe Allen](https://www.packet.net/about/zoe-allen/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy), [pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何确定你的Linux发行版中有没有某个软件包
|
Sk
|
https://www.ostechnix.com/find-if-a-package-is-available-for-your-linux-distribution/
|
有时，你可能会想知道如何在你的 Linux 发行版上寻找一个特定的软件包。或者，你仅仅只是想知道安装在你的 Linux 上的软件包有什么版本。
|
/data/attachment/album/201808/29/010140hp0gexe5nwgwqjqr.png.thumb.jpg
|
/data/attachment/album/201808/29/010140hp0gexe5nwgwqjqr.png
| true | false | true |
lujun9972
|
davidchenliang
|
wxy
| false |
[
"whohas",
"软件包"
] |
技术
|
{
"viewnum": 5263,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有时，你可能会想知道如何在你的 Linux 发行版上寻找一个特定的软件包。或者，你仅仅只是想知道安装在你的 Linux 上的软件包有什么版本。
| 2018-08-29T01:01:38 | 2018-08-29T01:01:38 | 9,960 |
/article-9960-1.html
|
有时，你可能会想知道如何在你的 Linux 发行版上寻找一个特定的软件包。或者，你仅仅只是想知道安装在你的 Linux 上的软件包有什么版本。如果这就是你想知道的信息，你今天走运了。我正好知道一个小工具能帮你抓到上述信息，下面隆重推荐—— Whohas：这是一个命令行工具，它能一次查询好几个软件包列表，以检查的你软件包是否存在。目前，whohas 支持 Arch、Debian、Fedora、Gentoo、Mandriva、openSUSE、Slackware、Source Mage、Ubuntu、FreeBSD、NetBSD、OpenBSD（LCTT 译注：\*BSD 不是 Linux）、Fink、MacPorts 和 Cygwin。使用这个小工具，软件包的维护者能轻而易举从别的 Linux 发行版里找到 ebuilds、 pkgbuilds 等等类似的包定义文件。
Whohas 是用 Perl 语言开发的自由、开源的工具。
### 在你的 Linux 中寻找一个特定的包
#### 安装 Whohas
Whohas 在 Debian、Ubuntu、Linux Mint 的默认软件仓库里提供。如果你正在使用某种基于 DEB 的系统，你可以用如下命令安装：
```
$ sudo apt-get install whohas
```
对基于 Arch 的系统，[AUR](https://aur.archlinux.org/packages/whohas/) 里就有提供 whohas。你能使用任何的 AUR 助手程序来安装。
使用 [Packer](https://www.ostechnix.com/install-packer-arch-linux-2/)：
```
$ packer -S whohas
```
或使用[Trizen](https://www.ostechnix.com/trizen-lightweight-aur-package-manager-arch-based-systems/)：
```
$ trizen -S whohas
```
使用[Yay](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/)：
```
$ yay -S whohas
```
使用 [Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/)：
```
$ yaourt -S whohas
```
在别的 Linux 发行版上，从[这里](http://www.philippwesche.org/200811/whohas/intro.html)下载源代码并手工编译安装。
#### 使用方法
Whohas 的主要目标是想让你知道：
* 哪个 Linux 发布版提供了用户依赖的包。
* 对于各个 Linux 发行版，指定的软件包是什么版本，或者在这个 Linux 发行版的各个不同版本上，指定的软件包是什么版本。
让我们试试看上面的的功能，比如说，哪个 Linux 发行版里有 vim 这个软件？我们可以运行如下命令：
```
$ whohas vim
```
这个命令将会显示所有包含可安装的 vim 的 Linux 发行版的信息，包括包的大小，仓库地址和下载URL。
你甚至可以通过管道将输出的结果按照发行版的字母排序，只需加入 `sort` 命令即可。
```
$ whohas vim | sort
```
请注意上述命令将会显示所有以 vim 开头的软件包，包括 vim-spell、vimcommander、vimpager 等等。你可以继续使用 Linux 的 `grep` 命令在 “vim” 的前后加上空格来缩小你的搜索范围，直到满意为止。
```
$ whohas vim | sort | grep " vim"
$ whohas vim | sort | grep "vim "
$ whohas vim | sort | grep " vim "
```
所有将空格放在包名字前面的搜索将会显示以包名字结尾的包。所有将空格放在包名字后面的搜索将会显示以包名字开头的包。前后都有空格将会严格匹配。
又或者，你就使用 `--strict` 来严格限制结果。
```
$ whohas --strict vim
```
有时，你想知道一个包在不在一个特定的 Linux 发行版里。例如，你想知道 vim 是否在 Arch Linux 里，请运行：
```
$ whohas vim | grep "^Arch"
```
（LCTT译注：在结果里搜索以 Arch 开头的 Linux）
Linux 发行版的命名缩写为：'archlinux'、'cygwin'、'debian'、'fedora'、 ‘fink'、'freebsd'、'gentoo'、'mandriva'、'macports'、'netbsd'、'openbsd'、'opensuse'、'slackware'、'sourcemage’ 和 ‘ubuntu'。
你也可以用 `-d` 选项来得到同样的结果。
```
$ whohas -d archlinux vim
```
这个命令将在仅仅 Arch Linux 发行版下搜索 vim 包。
如果要在多个 Linux 发行版下搜索，如 'archlinux'、'ubuntu'，请使用如下命令。
```
$ whohas -d archlinux,ubuntu vim
```
你甚至可以用 `whohas` 来查找哪个发行版有 whohas 包。
```
$ whohas whohas
```
更详细的信息，请参照手册。
```
$ man whohas
```
#### 最后的话
当然，任何一个 Linux 发行版的包管理器都能轻松的在对应的软件仓库里找到自己管理的包。不过，whohas 帮你整合并比较了在不同的 Linux 发行版下指定的软件包信息，这样你能轻易的跨平台之间进行比较。试一下 whohas，你一定不会失望的。
好了，今天就到这里吧，希望前面讲的对你有用，下次我还会带来更多好东西！！
欧耶！
---
via: <https://www.ostechnix.com/find-if-a-package-is-available-for-your-linux-distribution/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[DavidChenLiang](https://github.com/davidchenliang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
逃离 Google，重获自由（与君共勉）
|
Nithin Coca
|
https://medium.com/s/story/how-i-fully-quit-google-and-you-can-too-4c2f3f85793a
|
寻求挣脱科技巨头的一次开创性尝试
|
/data/attachment/album/201808/29/114356of3s69f6zr92esns.png.thumb.jpg
|
/data/attachment/album/201808/29/114356of3s69f6zr92esns.png
| true | false | true |
martin2011qi
|
pityonline
| true |
[
"Google"
] |
观点
|
{
"viewnum": 15843,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
寻求挣脱科技巨头的一次开创性尝试
| 2018-08-29T11:43:54 | 2018-08-29T11:43:54 | 9,961 |
/article-9961-1.html
|
>
> 寻求挣脱科技巨头的一次开创性尝试
>
>
>
在过去的六个月里，难以想象我到底经历了些什么。艰难的、耗时的、开创性的探索，为的只是完全摒弃一家公司 —— Google（谷歌）—— 的产品。本该是件简简单单的任务，但真要去做，花费在研究和测试上的又何止几个小时。但我成功了。现在，我已经不需要 Google 了，作为西方世界中极其少数的群体中的一份子，不再使用世界上最有价值的两家科技公司的产品（是的，我也不用 [Facebook（脸书）](https://www.nithincoca.com/2011/11/20/7-months-no-facebook/)）。
本篇指南将向你展示我逃离 Google 生态的始末。以及根据本人的研究和个人需求，选择的替代方案。我不是技术方面的专家，或者说程序员，但作为记者，我的工作要求我对安全和隐私的问题保持警惕。
我选择替代方案时，主要考察其本身的长处、可用性、成本、以及是否具备我需要的功能。我的选择并不是那么大众，仅反映我自身的需求和期许，也不牵涉任何商业利益。下面列出的所有替代方案都没有给我赞助，也从未试图花钱诱使我使用他们的服务。
### 首先我们需要知道：为什么？
你们说这事情整的，我和 Google 可无冤无仇。事实上，不久前我还是个忠实的 Google 粉。还是记得是 90 年代末，当时我还在读高中，我和 Google 搜索引擎的第一次邂逅，那一瞬的美简直惊为天人。那时候的 Google 可是领先了 Yahoo、Altavista、Ask Jeeves 这些公司好几年。Google 实打实地去帮用户找到他们想在网络上找的东西，但同样是那个时代，乌七八糟的网站和糟糕的索引遍地横生。
Google 很快就从仅提供检索服务转向提供其它服务，其中许多都是我欣然拥抱的服务。早在 2005 年，当时你们可能还只能[通过邀请](https://www.quora.com/How-long-was-Gmail-in-private-%28invitation-only%29-beta)加入 Gmail 的时候，我就已经是早期使用者了。Gmail 采用了线程对话、归档、标签，毫无疑问是我使用过的最好的电子邮件服务。当 Google 在 2006 年推出其日历工具时，那种对操作的改进绝对是革命性的。针对不同日历使用不同的颜色进行编排、检索事件、以及发送可共享的邀请，操作极其简单。2007 年推出的 Google Docs 同样令人惊叹。在我的第一份全职工作期间，我还促成我们团队使用支持多人同时编辑的 Google 电子表格、文档和演示文稿来完成日常工作。
和许多人一样，我也是 Google 开疆拓土过程中的受害者。从搜索（引擎）到电子邮件、文档、分析、再到照片，许多其它服务都建立在彼此之上，相互勾连。Google 从一家发布实用产品的公司转变成诱困用户的公司，与此同时将整个互联网转变为牟利和数据采集的机器。Google 在我们的数字生活中几乎无处不在，这种程度的存在远非其他公司可以比拟。与之相比使用其他科技巨头的产品想要抽身就相对容易。对于 Apple（苹果），你要么身处 iWorld 之中，要么是局外人。亚马逊亦是如此，甚至连 Facebook 也不过是拥有少数的几个平台，不用（Facebook）更多的是[心理挑战](https://www.theverge.com/2018/4/28/17293056/facebook-deletefacebook-social-network-monopoly)，实际上并没有多么困难。
然而，Google 无处不在。无论是笔记本电脑、智能手机或者平板电脑，我猜其中至少会有那么一个 Google 的应用程序。Google 就是搜索（引擎）、地图、电子邮件、浏览器和大多数智能手机操作系统的代名词。甚至还有些应用有赖于其提供的“[服务](https://en.wikipedia.org/wiki/Google_Play_Services)”和分析，比方说 Uber 便需要采用 Google 地图来运营其乘车服务。
Google 现在俨然已是许多语言中的单词，但彰显其超然全球统治地位的方面显然不止于此。可以说只要你不是极其注重个人隐私，那其庞大而成套的工具几乎没有多少众所周知或广泛使用的替代品。这恰好也是大家选择 Google 的原因，在很多方面能更好的替代现有的产品。但现在，使我们的难以割舍的主要原因其实是 Google 已经成为了默认选择，或者说由于其主导地位导致替代品无法对我们构成足够的吸引。
事实上，替代方案是存在的，这些年自<ruby> 爱德华·斯诺登 <rt> Edward Snowden </rt></ruby>披露 Google 涉事 <ruby> <a href="https://www.theguardian.com/world/2013/jun/06/us-tech-giants-nsa-data"> 棱镜 </a> <rt> Prism </rt></ruby>以来，又陆续涌现了许多替代品。我从去年年底开始着手这个项目。经过六个月的研究、测评以及大量的尝试和失败，我终于找到了所有我正在使用的 Google 产品对应的注重个人隐私的替代品。令我感到吃惊的是，其中的一些替代品比 Google 的做的还要好。
### 一些注意事项
这个过程中需要面临的几个挑战之一便是，大多数的替代方案，特别是那些注重隐私空间的开源替代方案，确实对用户不太友好。我不是技术人员，但是自己有一个网站，了解如何管理 Wordpress，可以排除一些基本的故障，但我用不来命令行，也做不来任何需要编码的事。
提供的这些替代方案中的大多数，即便不能完整替代 Google 产品的功能，但至少可以轻松上手。不过有些还是需要你有自己的 Web 主机或服务器的。
此外，[Google Takeout](https://takeout.google.com/settings/takeout) 是你的好帮手。我通过它下载了我所有的电子邮件历史记录，并将其上传到我的计算机上，再通过 Thunderbird 访问，这意味着我可以轻松访问这十几年的电子邮件。关于日历和文档也同样如此，我将后者转换为 ODT 格式，存在我的替代云上，下面我将进一步介绍其中的细节。
### 初级
#### 搜索引擎
[DuckDuckGo](https://duckduckgo.com/) 和 [startpage](https://www.startpage.com/) 都是以保护个人隐私为中心的搜索引擎，不收集任何搜索数据。我用这两个搜索引擎来负责之前用 Google 搜索的所有需求。
其它的替代方案：实际上并不多，Google 坐拥全球 74% 的市场份额时，剩下的那些主要是因为中国的原因。不过还有 Ask.com，以及 Bing……
#### Chrome
[Mozilla Firefox](https://www.mozilla.org/en-US/firefox/new/) —— 近期的[一次大升级](https://www.seattletimes.com/business/firefox-is-back-and-its-time-to-give-it-a-try/)，是对早期版本的巨大改进。是一个由积极致力于保护隐私的非营利基金会打造的浏览器。它的存在让你觉得没有必要死守 Chrome。
其它的替代方案：考虑到 Opera 和 Vivaldi 都基于 Chrome。[Brave](https://brave.com/) 浏览器是我的第二选择。
#### Hangouts（环聊）和 Google Chat
[Jitsi Meet](https://jitsi.org/jitsi-meet/) —— 一款 Google Hangouts 的开源免费替代方案。你可以直接在浏览器上使用或下载应用程序。快速，安全，几乎适用于所有平台。
其它的替代方案：Zoom 在专业领域渐受青睐，但大部分的特性需要付费。[Signal](https://signal.org/)，一个开源、安全的消息通讯类应用程序，可以用来打电话，不过仅限于移动设备。不推荐 Skype，既耗流量，界面还糟。
#### Google Maps（地图）
桌面端：[HERE WeGo](https://wego.here.com/) —— 加载速度更快，所有能在 Google Maps 找到的几乎都能找到。不过由于某些原因，还缺了一些国家，如日本。
移动端：[MAPS.ME](https://maps.me/) —— 我一开始用的就是这款地图，但是自从他们专注于导航模式后地图功能就有点鸡肋了。MAPS.ME 还是相当不错的，并且具有比 Google 更好的离线功能，这对像我这样的经常旅行的人来说非常好用。
其它的替代方案：[OpenStreetMap](https://www.openstreetmap.org/) 是我全心支持的一个项目，不过功能严重缺乏。甚至无法找到我在奥克兰的家庭住址。
### 初级（需付费）
当然其中有一部分是自作自受。例如，在寻找 Gmail 的替代品时，我想的不是仅仅从 Gmail 切换到另一家科技巨头产品作为替代。这就意味不会存在转到 Yahoo Mail 或 Microsoft Outlook 的情况，因为这并不能消除我对隐私问题的困扰。
请记住，虽说 Google 的许多服务都是免费的（更不必说包括 Facebook 在内的竞争对手的服务），那是因为他们正在积极地将我们的数据货币化。由于替代方案极力避免将数据货币化，这使他们不得不向我们收取费用。我愿意付钱来保护我的隐私，但也明白并非所有人都会做出这样的选择。
或许我们可以换一个方向来思考：可还曾记得以前寄信时也不得不支付邮票的费用吗？或者从商店购买周卡会员？从本质上讲，这就是使用注重隐私的电子邮件或日历应用程序的成本。也没那么糟。
#### Gmail
[ProtonMail](https://protonmail.com/) —— 由前 CERN（欧洲核子研究中心）的科学家创立，总部设在瑞士，一个拥有强大隐私保护的国家。但 ProtonMail 真正吸引我的地方是，它与大多数其它注重隐私的电子邮件程序不同，用户体验友好。界面类似于 Gmail，带标签，有过滤器和文件夹，无需了解任何有关安全性或隐私的信息即可使用。
免费版只提供 500MB 的存储空间。而我选择的是付费 5GB 帐户及其 VPN 服务。
其它的替代方案：[Fastmail](https://www.fastmail.com/) 不仅面向注重隐私的用户，界面也很棒。还有 [Hushmail](https://www.hushmail.com/) 和 [Tutanota](https://tutanota.com/)，两者都具有与 ProtonMail 相似的功能。
#### Calendar（日历）
[Fastmail](https://www.fastmail.com/) 日历 —— 这个决定异常艰难，也抛出了另一个问题。Google 的产品存在于很多方面，可以用无处不在来形容，这导致初创公司甚至不再费心去创造替代品。在尝试了其它一些平庸的选项后，我最后还是推荐并选择 Fastmail 同时作为备用电子邮件和日历的选项。
### 进阶
这些需要一些技术知识，或者需要你自己有 Web 主机。我尝试研究过更简单的替代方案，但最终都没能入围。
#### Google Docs（文档）、Drive（云端硬盘）、Photos（照片）和 Contacts（联系人）
[Nextcloud](https://nextcloud.com/) —— 一个功能齐全、安全并且开源的云套件，具有直观、友好的用户界面。问题是你需要自己有主机才能使用 Nextcloud。我有一个用于部署自己网站的主机，并且能够使用 Softaculous 在我主机的 C-Panel 上快速安装 Nextcloud。你需要一个 HTTPS 证书，我从 [Let’s Encrypt](https://letsencrypt.org/) 上免费获得了一个。不似开通 Google Drive 帐户那般容易，但也不是很难。
同时我也在用 Nextcloud 作为 Google 的照片存储和联系人的替代方案，然后通过 CalDev 与手机同步。
其它的替代方案：还有其它开源选项，如 [ownCloud](https://owncloud.org/) 或者 [Openstack](https://www.openstack.org/)。一些营利的选项也很不错，因为作为首选的 Dropbox 和 Box 也没有采用从你的数据中牟利的运营模式。
#### Google Analytics（分析）
[Matomo](https://matomo.org/) —— 正式名为 Piwic，这是一个自托管的分析平台。虽然不像 Google 分析那样功能丰富，但可以很好地分析基本的网站流量，还有一个额外的好处，就是你无需为 Google 贡献流量数据了。
其它的替代方案：真的不多。[OpenWebAnalytics](http://www.openwebanalytics.com/) 是另一个开源选择，还有一些营利性的选择，比如 GoStats 和 Clicky。
#### Android（安卓）
[LineageOS](https://lineageos.org/) + [F-Droid App Store](https://f-droid.org/en/)。可悲的是，智能手机世界已成为一个事实上的双头垄断，Google 的 Android 和 Apple 的 iOS 控制着整个市场。几年前存在的几个可用的替代品，如 Blackberry OS 或 Mozilla 的 Firefox OS，也已不再维护。
因此，只能选择次一级的 Lineage OS：一款注重隐私的、开源的 Android 版本，Google 服务及 APP 是选装的。这需要懂一些技术知识，因为安装的整个过程并不是那么一帆风顺，但运行状况良好，且不似大多数 Android 那般有大量预置软件。
其它的替代方案：呃…… Windows 10 Mobile？[PureOS](https://puri.sm/posts/tag/pureos/) 看起来有那么点意思，[UbuntuTouch](https://ubports.com/) 也差不多。
### 意想不到的挑战
首先，由于有关可用替代方案的优质资源匮乏，以及将数据从 Google 迁移到其它平台所面临的挑战，所以比我计划的时间要长许多。
但最棘手的是电子邮件，这与 ProtonMail 或 Google 无关。
在我 2004 年加入 Gmail 之前，我可能每年都会切换一次电子邮件。我的第一个帐户是使用 Hotmail，然后我使用了 Mail.com，Yahoo Mail 以及像 Bigfoot 这样被遗忘已久的服务。当我在变更电子邮件提供商时，我未曾记得有这般麻烦。我会告诉所有朋友，更新他们的地址簿，并更改其它网络帐户的邮箱地址。以前定期更改邮箱地址非常必要 —— 还记得曾几何时垃圾邮件是如何盘踞你旧收件箱的吗？
事实上，Gmail 最好的创新之一就是能够将垃圾邮件过滤掉。这意味着再也不用频繁更改邮箱地址了。
电子邮件是使用互联网的关键。你需要用它来开设 Facebook 帐户，使用网上银行，在留言板上发布等等。因此，当你决定切换帐户时，你就需要更新所有这些不同服务的邮箱地址。
令人惊讶的是，现在从 Gmail 迁出居然成为了最大的麻烦，因为遍地都需要通过邮箱地址来设置帐户。有几个站点不再允许你从后台执行此操作。有个服务事实上就是让我注销现在的帐户，然后开通一个新的，只因他们无法更改我的邮箱地址，然后他们手动转移了我的帐户数据。另一些迫使我打电话给客服要求更改邮箱地址，无谓的浪费了很多时间。
更令人惊讶的是，另一些服务接受了我的更改，却仍继续向我原来的 Gmail 帐户发送邮件，就需要打一次电话了。另一些甚至更烦人，向我的新电子邮件发送了一些消息，但仍在使用我的旧帐户发送其它电子邮件。这事最后变得异常繁琐，迫使我不得不将我的 Gmail 帐户和我新的 ProtonMail 帐户同时开了几个月，以确保重要的电子邮件不会丢失。这是我花了六个月时间的主要元凶。
如今人们很少变更他们的邮箱地址，大多数公司的平台在设计时就没有考虑去处理这种可能性。这是表明当今网络糟糕状态的一个明显迹象，即便是在 2002 年更改邮箱地址都比 2018 年来的容易。技术也并不总是一成不变的向前发展。
### 那么，这些 Google 的替代方案都好用吗？
有些确实更好！Jitsi Meet 运行更顺畅，需要的带宽更少，并且比 Hangouts 跨平台支持好。Firefox 比 Chrome 更稳定，占用的内存更少。Fastmail 的日历具有更好的时区集成。
还有些旗鼓相当。ProtonMail 具有 Gmail 的大部分功能，但缺少一些好用的集成，例如我之前使用的 Boomerang 邮件日程功能。还缺少联系人界面，但我正在使用 Nextcloud。说到 Nextcloud，它非常适合托管文件、联系人，还包含了一个漂亮的笔记工具（以及诸多其它插件）。但它没有 Google Docs 丰富的多人编辑功能。在我的预算中，还没有找到可行的替代方案。虽然还有 Collabora Office，但这需要升级我的服务器，这对我来说不能算切实可行。
一些取决于位置。在一些国家（如印度尼西亚），MAPS.ME 实际上比 Google 地图更好用，而在另一些国家（包括美国）就差了许多。
还有些要求用户牺牲一些特性或功能。Piwic 是一个穷人版的 Google Analytics，缺乏前者的许多详细报告和搜索功能。DuckDuckGo 适用于一般搜索，但是在特定的搜索方面还存在问题，当我搜索非英文内容时，它和 startpage 时常都会检索失败。
### 最后，我不再心念 Google
事实上，我觉得我解放了。如此这般依赖单一公司的那么多产品是一种形式上奴役，特别是当你的数据经常为你买单的时候。而且，其中许多替代方案实际上更好。清楚自己正掌控自己数据的感觉真得很爽。
如果我们别无选择，只能使用 Google 的产品，那我们便失去了作为消费者的最后一丝力量。
我希望 Google、Facebook、Apple 和其他科技巨头在对待用户时不要这么理所当然，不要试图强迫我们进入其无所不包的生态系统。我也期待新选手能够出现并与之竞争，就像以前一样，Google 的新搜索工具可以与当时的行业巨头 Altavista 和 Yahoo 竞争，或者说 Facebook 的社交网络能够与 MySpace 和 Friendster 竞争。Google 给出了更好的搜索方案，使互联网变得更加美好。有选择是个好事，可移植也是。
如今，我们很少有人哪怕只是尝试其它产品，因为我们已经习惯了 Google。我们不再更改邮箱地址，因为这太难了。我们甚至不尝试使用 Facebook 以外的替代品，因为我们所有的朋友都在 Facebook 上。这些我明白。
你不必完全脱离 Google。但最好给其它选择一个机会。到时候时你可能会感到惊讶，并想起那些年上网的初衷。
---
### 其它资源
我并未打算让这篇文章成为包罗万象的指南，这只不过是一个关于我如何脱离 Google 的故事。以下的那些资源会向你展示其它替代方案。其中有一些对我来说过于专业，还有一些我还没有时间去探索。
* [Localization Lab](https://www.localizationlab.org/projects/) 一份开源或注重隐私技术的项目的详细清单 —— 有些技术含量高，有些用户友好度比较好。
* [Framasoft](https://framasoft.org/?l=en) 有一整套针对 Google 的替代方案，大部分是开源的，虽然大部分是法语。
* Restore Privacy 也[整理了一份替代方案的清单](https://restoreprivacy.com/google-alternatives/)。
到你了。你可以直接回复或者通过 Twitter 来分享你喜欢的 Google 产品的替代方案。我确信我遗漏了许多，也非常乐意尝试。我并不打算一直固守我列出的这些方案。
---
作者简介：
Nithin Coca
自由撰稿人，涵盖政治，环境和人权以及全球科技的社会影响。更多参考 <http://www.nithincoca.com>
---
via: <https://medium.com/s/story/how-i-fully-quit-google-and-you-can-too-4c2f3f85793a>
作者：[Nithin Coca](https://medium.com/@excinit) 译者：[martin2011qi](https://github.com/martin2011qi) 校对：[pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
一套有用的 Unix 实用程序
|
Sk
|
https://www.ostechnix.com/moreutils-collection-useful-unix-utilities/
|
还有更多有用的实用程序没有预装在类 Unix 操作系统中，它们汇集起来构成了 moreutilis 这个日益增长的集合。
|
/data/attachment/album/201808/30/083152srjrplj9m94899c9.png.thumb.jpg
|
/data/attachment/album/201808/30/083152srjrplj9m94899c9.png
| true | false | true |
lujun9972
|
pinewall
|
wxy
| false |
[
"moreutils"
] |
分享
|
{
"viewnum": 7464,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
还有更多有用的实用程序没有预装在类 Unix 操作系统中，它们汇集起来构成了 moreutilis 这个日益增长的集合。
| 2018-08-30T08:31:49 | 2018-08-30T08:31:49 | 9,962 |
/article-9962-1.html
|
我们都了解 <ruby> GNU 核心实用程序 <rt> GNU Core Utilities </rt></ruby>，所有类 Unix 操作系统都预装了它们。它们是 GNU 操作系统中与文件、Shell 和 文本处理相关的基础实用工具。GNU 核心实用程序包括很多日常操作命令，例如 `cat`、`ls`、`rm`、`mkdir`、`rmdir`、`touch`、`tail` 和 `wc` 等。除了这些实用程序，还有更多有用的实用程序没有预装在类 Unix 操作系统中，它们汇集起来构成了 `moreutilis` 这个日益增长的集合。`moreutils` 可以在 GNU/Linux 和包括 FreeBSD，openBSD 及 Mac OS 在内的多种 Unix 类型操作系统上安装。
截至到编写这份指南时， `moreutils` 提供如下实用程序：
* `chronic` – 运行程序并忽略正常运行的输出
* `combine` – 使用布尔操作合并文件的行
* `errno` – 查询 errno 名称及描述
* `ifdata` – 获取网络接口信息，无需解析 `ifconfig` 的结果
* `ifne` – 在标准输入非空的情况下运行程序
* `isutf8` – 检查文件或标准输入是否采用 UTF-8 编码
* `lckdo` – 带锁运行程序
* `mispipe` – 使用管道连接两个命令，返回第一个命令的退出状态
* `parallel` – 同时运行多个任务
* `pee` – 将标准输入传递给多个管道
* `sponge` – 整合标准输入并写入文件
* `ts` – 为标准输入增加时间戳信息
* `vidir` – 使用你默认的文本编辑器操作目录文件
* `vipe` – 在管道中插入信息编辑
* `zrun` – 自动解压并将其作为参数传递给命令
### 在 Linux 上安装 moreutils
由于 `moreutils` 已经被打包到多种 Linux 发行版中，你可以使用发行版对应的软件包管理器安装 `moreutils`。
在 **Arch Linux** 或衍生的 **Antergos** 和 **Manjaro Linux** 上，运行如下命令安装 `moreutils`:
```
$ sudo pacman -S moreutils
```
在 **Fedora** 上，运行：
```
$ sudo dnf install moreutils
```
在 **RHEL**，**CentOS** 和 **Scientific Linux** 上，运行：
```
$ sudo yum install epel-release
$ sudo yum install moreutils
```
在 **Debian**，**Ubuntu** 和 **Linux Mint** 上，运行：
```
$ sudo apt-get install moreutils
```
### Moreutils – 打包更多有用的 Unix 实用程序
让我们看一下几个 `moreutils` 工具的用法细节。
#### combine 实用程序
正如 `combine` 名称所示，moreutils 中的这个实用程序可以使用包括 `and`，`not`，`or` 和 `xor` 在内的布尔操作，合并两个文件中的行。
* `and` – 输出 `file1` 和 `file2` 都包含的行。
* `not` – 输出 `file1` 包含但 `file2` 不包含的行。
* `or` – 输出 `file1` 或 `file2` 包含的行。
* `xor` – 输出仅被 `file1` 或 `file2` 包含的行
下面举例说明，方便你理解该实用程序的功能。这里有两个文件，文件名分别为 `file1` 和 `file2`，其内容如下：
```
$ cat file1
is
was
were
where
there
$ cat file2
is
were
there
```
下面，我使用 `and` 布尔操作合并这两个文件。
```
$ combine file1 and file2
is
were
there
```
从上例的输出中可以看出，`and` 布尔操作只输出那些 `file1` 和 `file2` 都包含的行；更具体的来说，命令输出为两个文件共有的行，即 is，were 和 there。
下面我们换成 `not` 操作，观察一下输出。
```
$ combine file1 not file2
was
where
```
从上面的输出中可以看出，`not` 操作输出 `file1` 包含但 `file2` 不包含的行。
#### ifdata 实用程序
`ifdata` 实用程序可用于检查网络接口是否存在，也可用于获取网络接口的信息，例如 IP 地址等。与预装的 `ifconfig` 和 `ip` 命令不同，`ifdata` 的输出更容易解析，这种设计的初衷是便于在 Shell 脚本中使用。
如果希望查看某个接口的 IP 地址，不妨以 `wlp9s0` 为例，运行如下命令：
```
$ ifdata -p wlp9s0
192.168.43.192 255.255.255.0 192.168.43.255 1500
```
如果只查看掩码信息，运行如下命令：
```
$ ifdata -pn wlp9s0
255.255.255.0
```
如果查看网络接口的物理地址，运行如下命令：
```
$ ifdata -ph wlp9s0
A0:15:46:90:12:3E
```
如果判断接口是否存在，可以使用 `-pe` 参数：
```
$ ifdata -pe wlp9s0
yes
```
#### pee 命令
该命令某种程度上类似于 `tee` 命令。
我们先用一个例子看一下 `tee` 的用法。
```
$ echo "Welcome to OSTechNIx" | tee file1 file2
Welcome to OSTechNIx
```
上述命令首先创建两个文件，名为 `file1` 和 `file2`；接着，将 “Welcome to OSTechNix” 行分别附加到两个文件中；最后，在终端中打印输出 “Welcome to OSTechNix”。
`pee` 命令提供类似的功能，但与 `tee` 又稍微有些差异。查看下面的例子：
```
$ echo "Welcome to OSTechNIx" | pee cat cat
Welcome to OSTechNIx
Welcome to OSTechNIx
```
从上面的命令输出中可以看出，有两个 `cat` 命令实例获取 `echo` 命令的输出并执行，因而终端中出现两个同样的输出。
#### sponge 实用程序
这是 `moreutils` 软件包中的另一个有用的实用程序。`sponge` 读取标准输入并写入到指定的文件中。与 Shell 中的重定向不同，`sponge` 接收到完整输入后再写入输出文件。
查看下面这个文本文件的内容：
```
$ cat file1
I
You
Me
We
Us
```
可见，文件包含了一些无序的行；更具体的说，这些行“没有”按照字母顺序排序。如果希望将其内容安装字母顺序排序，你会怎么做呢？
```
$ sort file1 > file1_sorted
```
这样做没错，对吧？当然没错！在上面的命令中，我将 `file1` 文件内容按照字母顺序排序，将排序后的内容保存在 `file1_sorted` 文件中。但如果使用 `sponge` 命令，你可以在不创建新文件（即 `file1_sorted`）的情况下完成同样的任务，命令如下：
```
$ sort file1 | sponge file1
```
那么，让我们检查一下文件内容是否已经按照字母顺序排序：
```
$ cat file1
I
Me
Us
We
You
```
看到了吧？并不需要创建新文件。在脚本编程中，这非常有用。另一个好消息是，如果待写入的文件已经存在，`sponge` 会保持其<ruby> 权限信息 <rt> permissions </rt></ruby>不变。
#### ts 实用程序
正如名称所示，`ts` 命令在每一行输出的行首增加<ruby> 时间戳 <rt> timestamp </rt></ruby>。
查看如下命令的输出：
```
$ ping -c 2 localhost
PING localhost(localhost.localdomain (::1)) 56 data bytes
64 bytes from localhost.localdomain (::1): icmp_seq=1 ttl=64 time=0.055 ms
64 bytes from localhost.localdomain (::1): icmp_seq=2 ttl=64 time=0.079 ms
--- localhost ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1018ms
rtt min/avg/max/mdev = 0.055/0.067/0.079/0.012 ms
```
下面，结合 `ts` 实用程序运行同样地命令：
```
$ ping -c 2 localhost | ts
Aug 21 13:32:28 PING localhost(localhost (::1)) 56 data bytes
Aug 21 13:32:28 64 bytes from localhost (::1): icmp_seq=1 ttl=64 time=0.063 ms
Aug 21 13:32:28 64 bytes from localhost (::1): icmp_seq=2 ttl=64 time=0.113 ms
Aug 21 13:32:28
Aug 21 13:32:28 --- localhost ping statistics ---
Aug 21 13:32:28 2 packets transmitted, 2 received, 0% packet loss, time 4ms
Aug 21 13:32:28 rtt min/avg/max/mdev = 0.063/0.088/0.113/0.025 ms
```
对比输出可以看出，`ts` 在每一行行首增加了时间戳。下面给出另一个例子：
```
$ ls -l | ts
Aug 21 13:34:25 total 120
Aug 21 13:34:25 drwxr-xr-x 2 sk users 12288 Aug 20 20:05 Desktop
Aug 21 13:34:25 drwxr-xr-x 2 sk users 4096 Aug 10 18:44 Documents
Aug 21 13:34:25 drwxr-xr-x 24 sk users 12288 Aug 21 13:06 Downloads
[...]
```
#### vidir 实用程序
`vidir` 实用程序可以让你使用 `vi` 编辑器（或其它 `$EDITOR` 环境变量指定的编辑器）编辑指定目录的内容。如果没有指定目录，`vidir` 会默认编辑你当前的目录。
下面的命令编辑 `Desktop` 目录的内容：
```
$ vidir Desktop/
```
上述命令使用 `vi` 编辑器打开了指定的目录，其中目录内的文件都会对应一个数字。下面你可以按照 `vi` 的操作方式来编辑目录中的这些文件：例如，删除行意味着删除目录中对应的文件，修改行中字符串意味着对文件进行重命名。
你也可以编辑子目录。下面的命令会编辑当前目录及所有子目录：
```
$ find | vidir -
```
请注意命令结尾的 `-`。如果 `-` 被指定为待编辑的目录，`vidir` 会从标准输入读取一系列文件名，列出它们让你进行编辑。
如果你只想编辑当前目录下的文件，可以使用如下命令：
```
$ find -type f | vidir -
```
只想编辑特定类型的文件，例如 `.PNG` 文件？你可以使用如下命令：
```
$ vidir *.png
```
这时命令只会编辑当前目录下以 `.PNG` 为后缀的文件。
#### vipe 实用程序
`vipe` 命令可以让你使用默认编辑器接收 Unix 管道输入，编辑之后使用管道输出供下一个程序使用。
执行下面的命令会打开 `vi` 编辑器（当然是我默认使用的编辑器），你可以编辑 `echo` 命令的管道输入（即 “Welcome to OSTechNix”），最后将编辑过的内容输出到终端中。
```
$ echo "Welcome to OSTechNIx" | vipe
Hello World
```
从上面的输出可以看出，我通过管道将 “Welcome to OSTechNix” 输入到 `vi` 编辑器中，将内容编辑为 “Hello World”，最后显示该内容。
好了，就介绍这么多吧。我只介绍了一小部分实用程序，而 `moreutils` 包含更多有用的实用程序。我在文章开始的时候已经列出目前 `moreutils` 软件包内包含的实用程序，你可以通过 `man` 帮助页面获取更多相关命令的细节信息。举个例子，如果你想了解 `vidir` 命令，请运行：
```
$ man vidir
```
希望这些内容对你有所帮助。我还将继续分享其它有趣且实用的指南，如果你认为这些内容对你有所帮助，请分享到社交网络或专业圈子，也欢迎你支持 OSTechNix 项目。
干杯！
---
via: <https://www.ostechnix.com/moreutils-collection-useful-unix-utilities/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 桌面中 4 个开源媒体转换工具
|
Scott Nesbitt
|
https://opensource.com/article/18/7/media-conversion-tools-linux
|
使用这些易用的工具来将音视频文件从一种格式转换为另一种格式。
|
/data/attachment/album/201808/30/224953v2r22dzmc95y2oo1.png.thumb.jpg
|
/data/attachment/album/201808/30/224953v2r22dzmc95y2oo1.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"音视频",
"转换"
] |
分享
|
{
"viewnum": 8822,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用这些易用的工具来将音视频文件从一种格式转换为另一种格式。
| 2018-08-30T22:49:37 | 2018-08-30T22:49:37 | 9,963 |
/article-9963-1.html
|
>
> 使用这些易用的工具来将音视频文件从一种格式转换为另一种格式。
>
>
>
啊，有这么多的文件格式，特别是音频和视频格式，如果你不认识这个文件扩展名或者你的播放器无法播放那个格式，或者你想使用一种开放格式，那就需要花点心思了。
那么，Linux 用户可以做些什么呢？当然是去使用 Linux 桌面的众多开源媒体转换工具之一。我们来看看其中的四个。
### Gnac
[Gnac](http://gnac.sourceforge.net) 是我最喜欢的音频转换器之一，已经存在很多年了。它易于使用，功能强大，并且它做得很好 —— 任何一流的程序都应该如此。
有多简单？单击工具栏按钮添加一个或多个要转换的文件，选择要转换的格式，然后单击**Convert**。转换很快，而且很干净。
有多强大？Gnac 可以处理 [GStreamer](http://www.gstreamer.net/) 多媒体框架支持的所有音频格式。开箱即用，你可以在 Ogg、FLAC、AAC、MP3、WAV 和 SPX 之间进行转换。你还可以更改每种格式的转换选项或添加新格式。
### SoundConverter
如果在简单的同时你还要一些额外的功能，那么请看一下 [SoundConverter](http://soundconverter.org/)。正如其名称所述，SoundConverter 仅对音频文件起作用。与 Gnac 一样，它可以读取 GStreamer 支持的格式，它可以输出 Ogg Vorbis、MP3、FLAC、WAV、AAC 和 Opus 文件。
通过单击 **Add File** 或将其拖放到 SoundConverter 窗口中来加载单个文件或整个文件夹。单击 **Convert**，软件将完成转换。它也很快 —— 我已经在大约一分钟内转换了一个包含几十个文件的文件夹。
SoundConverter 有设置转换文件质量的选项。你可以更改文件的命名方式（例如，在标题中包含曲目编号或专辑名称），并为转换后的文件创建子文件夹。
### WinFF
[WinFF](https://www.biggmatt.com/winff/) 本身并不是转换器。它是 FFmpeg 的图形化前端，[Tim Nugent 为此](https://opensource.com/article/17/6/ffmpeg-convert-media-file-formats) 在 Opensource.com 写了篇文章。虽然 WinFF 没有 FFmpeg 的所有灵活性，但它使 FFmpeg 更易于使用，并且可以快速，轻松地完成工作。
虽然它不是这里最漂亮的程序，也不需要是。它远比可以使用要好。你可以从下拉列表中选择要转换的格式，并选择多个预设配置。最重要的是，你可以指定比特率和帧速率，要使用的音频通道数量，甚至裁剪视频的大小等选项。
转换，特别是视频，需要一些时间，但结果通常非常好。有时，转换会有点受损 —— 但往往不足以引起关注。而且，正如我之前所说，使用 WinFF 可以节省一些时间。
### Miro Video Converter
并非所有视频文件都是同样创建的。有些是专有格式。有的在显示器或电视屏幕上看起来很棒但是没有针对移动设备进行优化。这就是 [Miro Video Converter](http://www.mirovideoconverter.com/) 可以用的地方。
Miro Video Converter 非常重视移动设备。它可以转换在 Android 手机、Apple 设备、PlayStation Portable 和 Kindle Fire 上播放的视频。它会将最常见的视频格式转换为 MP4、[WebM](https://en.wikipedia.org/wiki/WebM) 和 [Ogg Theora](https://en.wikipedia.org/wiki/Ogg_theora)。你可以[在 Miro 的网站](http://www.mirovideoconverter.com/)上找到支持的设备和格式的完整列表
要使用它，可以将文件拖放到窗口中，也可以选择要转换的文件。然后，单击“Format”菜单以选择转换的格式。你还可以单击 Apple、Android 或其他菜单以选择要转换文件的设备。Miro Video Converter 会为设备屏幕分辨率调整视频大小。
你有最喜欢的 Linux 媒体转换程序吗？请留下评论，随意分享。
---
via: <https://opensource.com/article/18/7/media-conversion-tools-linux>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Ansible 实现网络自动化
|
Jason Edelman
|
https://www.oreilly.com/learning/network-automation-with-ansible
|
了解 Ansible 的功能，这是一个无代理的、可扩展的配置管理系统。
|
/data/attachment/album/201808/30/230933i0vdnu22vvfd9oi0.jpg.thumb.jpg
|
/data/attachment/album/201808/30/230933i0vdnu22vvfd9oi0.jpg
| true | false | true |
qhwdw
|
wxy
| false |
[
"ansible"
] |
系统运维
|
{
"viewnum": 17674,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解 Ansible 的功能，这是一个无代理的、可扩展的配置管理系统。
| 2018-08-30T23:09:00 | 2018-08-30T23:09:00 | 9,964 |
/article-9964-1.html
|
>
> 了解 Ansible 的功能，这是一个无代理的、可扩展的配置管理系统。
>
>
>
### 网络自动化
随着 IT 行业的技术变化，从服务器虚拟化到公有云和私有云，以及自服务能力、容器化应用、平台即服务（PaaS）交付，而一直以来落后的一个领域就是网络。
在过去的五年多，网络行业似乎有很多新的趋势出现，它们中的很多被归入到<ruby> 软件定义网络 <rt> software-defined networking </rt></ruby>（SDN）。
>
> 注意：
>
>
> SDN 是新出现的一种构建、管理、操作和部署网络的方法。SDN 最初的定义是出于将控制层和数据层（包转发）物理分离的需要，并且，解耦合的控制层必须管理好各自的设备。
>
>
> 如今，在 SDN 旗下已经有许多技术，包括<ruby> 基于控制器的网络 <rt> controller-based networks </rt></ruby>、网络设备 API、网络自动化、<ruby> 白盒交换机 <rt> whitebox switche </rt></ruby>、策略网络化、<ruby> 网络功能虚拟化 <rt> Network Functions Virtualization </rt></ruby>（NFV）等等。
>
>
> 出于这篇报告的目的，我们参考 SDN 的解决方案作为我们的解决方案，其中包括一个网络控制器作为解决方案的一部分，并且提升了该网络的可管理性，但并不需要从数据层解耦控制层。
>
>
>
这些趋势的之一是，网络设备的 API 作为管理和操作这些设备的一种方法而出现，真正地提供了机器对机器的通讯。当需要自动化和构建网络应用时 API 简化了开发过程，在数据如何建模时提供了更多结构。例如，当启用 API 的设备以 JSON/XML 返回数据时，它是结构化的，并且比返回原生文本信息 —— 需要手工去解析的仅支持命令行的设备更易于使用。
在 API 之前，用于配置和管理网络设备的两个主要机制是命令行接口（CLI）和简单网络管理协议（SNMP）。让我们来了解一下它们，CLI 是一个设备的人机界面，而 SNMP 并不是为设备提供的实时编程接口。
幸运的是，因为很多供应商争相为设备增加 API，有时候 *只是因为* 它被放到需求建议书（RFP）中，这就带来了一个非常好的副作用 —— 支持网络自动化。当真正的 API 发布时，访问设备内数据的过程，以及管理配置，就会被极大简化，因此，我们将在本报告中对此进行评估。虽然使用许多传统方法也可以实现自动化，比如，CLI/SNMP。
>
> 注意：
>
>
> 随着未来几个月或几年（LCTT 译注：本文发表于 2016 年）的网络设备更新，供应商的 API 无疑应该被做为采购网络设备（虚拟和物理）的关键决策标准而测试和使用。如果供应商提供一些库或集成到自动化工具中，或者如果被用于一个开放的标准或协议，用户应该知道数据是如何通过设备建模的，API 使用的传输类型是什么。
>
>
>
总而言之，网络自动化，像大多数类型的自动化一样，是为了更快地工作。工作的更快是好事，减少部署和配置改变的时间并不总是许多 IT 组织需要去解决的问题。
包括速度在内，我们现在看看这些各种类型的 IT 组织逐渐采用网络自动化的几种原因。你应该注意到，同样的原则也适用于其它类型的自动化。
#### 简化架构
今天，每个网络都是一片独特的“雪花”，并且，网络工程师们为能够通过一次性的网络改变来解决传输和应用问题而感到自豪，而这最终导致网络不仅难以维护和管理，而且也很难去实现自动化。
网络自动化和管理需要从一开始就包含到新的架构和设计中去部署，而不是作为一个二级或三级项目。哪个特性可以跨不同的供应商工作？哪个扩展可以跨不同的平台工作？当使用具体的网络设备平台时，API 类型或者自动化工程是什么？当这些问题在设计过程之前得到答案，最终的架构将变成简单的、可重复的、并且易于维护 *和* 自动化的，在整个网络中将很少启用供应商专用的扩展。
#### 确定的结果
在一个企业组织中，<ruby> 改变审查会议 <rt> change review meeting </rt></ruby>会评估面临的网络变化、它们对外部系统的影响、以及回滚计划。在人们通过 CLI 来执行这些 *面临的变化* 的世界上，输入错误的命令造成的影响是灾难性的。想像一下，一个有 3 位、4 位、5位，或者 50 位工程师的团队。每位工程师应对 *面临的变化* 都有他们自己的独特的方法。并且，在管理这些变化的期间，一个人使用 CLI 或者 GUI 的能力并不会消除和减少出现错误的机率。
使用经过验证的和测试过的网络自动化可以帮助实现更多的可预测行为，并且使执行团队更有可能实现确实性的结果，首次在保证任务没有人为错误的情况下正确完成的道路上更进一步。
#### 业务灵活性
不用说，网络自动化不仅为部署变化提供了速度和灵活性，而且使得根据业务需要去从网络设备中检索数据的速度变得更快。自从服务器虚拟化到来以后，服务器和虚拟化使得管理员有能力在瞬间去部署一个新的应用程序。而且，随着应用程序可以更快地部署，随之浮现的问题是为什么还需要花费如此长的时间配置一个 VLAN（虚拟局域网）、路由器、FW ACL（防火墙的访问控制列表）或者负载均衡策略呢？
通过了解在一个组织内最常见的工作流和 *为什么* 真正需要改变网络，部署如 Ansible 这样的现代的自动化工具将使这些变得非常简单。
这一章介绍了一些关于为什么应该去考虑网络自动化的高级知识点。在下一节，我们将带你去了解 Ansible 是什么，并且继续深入了解各种不同规模的 IT 组织的网络自动化的不同类型。
### 什么是 Ansible？
Ansible 是存在于开源世界里的一种最新的 IT 自动化和配置管理平台。它经常被拿来与其它工具如 Puppet、Chef 和 SaltStack 去比较。Ansible 作为一个由 Michael DeHaan 创建的开源项目出现于 2012 年，Michael DeHaan 也创建了 Cobbler 和 cocreated Func，它们在开源社区都非常流行。在 Ansible 开源项目创建之后不足 18 个月时间， Ansilbe 公司成立，并收到了六百万美金 A 轮投资。该公司成为 Ansible 开源项目排名第一的贡献者和支持者，并一直保持着。在 2015 年 10 月，Red Hat 收购了 Ansible 公司。
但是，Ansible 到底是什么？
*Ansible 是一个无需代理和可扩展的超级简单的自动化平台。*
让我们更深入地了解它的细节，并且看一看那些使 Ansible 在行业内获得广泛认可的属性。
#### 简单
Ansible 的其中一个吸引人的属性是，使用它你 **不** 需要特定的编程技能。所有的指令，或者说任务都是自动化的，以一个标准的、任何人都可以理解的人类可读的数据格式的文档化。在 30 分钟之内完成安装和自动化任务的情况并不罕见！
例如，下列来自一个 Ansible <ruby> 剧本 <rt> playbook </rt></ruby>的任务用于去确保在一个 VLAN 存在于一个 Cisco Nexus 交换机中：
```
- nxos_vlan: vlan_id=100 name=web_vlan
```
你无需熟悉或写任何代码就可以明确地看出它将要做什么！
>
> 注意：
>
>
> 这个报告的下半部分涉到 Ansible 术语（<ruby> 剧本 <rt> playbook </rt></ruby>、<ruby> 剧集 <rt> play </rt></ruby>、<ruby> 任务 <rt> task </rt></ruby>、<ruby> 模块 <rt> module </rt></ruby>等等）的细节。在我们使用 Ansible 进行网络自动化时，提及这些关键概念时我们会有一些简短的示例。
>
>
>
#### 无代理
如果你看过市面上的其它工具，比如 Puppet 和 Chef，你会发现，一般情况下，它们要求每个实现自动化的设备必须安装特定的软件。这种情况在 Ansible 上 *并不*需要，这就是为什么 Ansible 是实现网络自动化的最佳选择的主要原因。
这很好理解，那些 IT 自动化工具，包括 Puppet、Chef、CFEngine、SaltStack、和 Ansible，它们最初构建是为管理和自动化配置 Linux 主机，以跟得上部署的应用程序增长的步伐。因为 Linux 系统是被配置成自动化的，要安装代理并不是一个技术难题。如果有的话，它也只会延误安装过程，因为，现在有 *N* 多个（你希望去实现自动化的）主机需要在它们上面部署软件。
再加上，当使用代理时，它们需要的 DNS 和 NTP 配置更加复杂。这些都是大多数环境中已经配置好的服务，但是，当你希望快速地获取一些东西或者只是简单地想去测试一下它能做什么的时候，它将极大地耽误整个设置和安装的过程。
由于本报告只是为介绍利用 Ansible 实现网络自动化，我们希望指出，Ansible 作为一个无代理平台，对于网络管理员来说，其比对系统管理员更具有吸引力。这是为什么呢？
正如前面所说的那样，对网络管理员来说，它是非常有吸引力的，Linux 操作系统是开源的，并且，任何东西都可以安装在它上面。对于网络来说，却并非如此，虽然它正在逐渐改变。如果我们更广泛地部署网络操作系统，如 Cisco IOS，它就是这样的一个例子，并且问一个问题， *“第三方软件能否部署在基于 IOS （LCTT 译注：此处的 IOS，指的是思科的网络操作系统 IOS）的平台上吗？”*毫无疑问，它的回答是 *NO*。
在过去的二十多年里，几乎所有的网络操作系统都是闭源的，并且，垂直整合到底层的网络硬件中。没有供应商的支持，在一个网络设备中（路由器、交换机、负载均衡、防火墙、等等）载入一个代理并不那么轻松。有一个像 Ansible 这样的自动化平台，从头开始去构建一个无代理、可扩展的自动化平台，就像是它专门为网络行业订制的一样。我们最终将开始减少并消除与网络的人工交互。
#### 可扩展
Ansible 的可扩展性也非常的好。从开源、代码开始在网络行业中发挥重要的作用时起，有一个可扩展的平台是必需的。这意味着如果供应商或社区不提供一个特定的特性或功能，开源社区、终端用户、消费者、顾问，或者任何的人能够 *扩展* Ansible 来启用一个给定的功能集。过去，网络供应商或者工具供应商通过一个 hook 去提供新的插件和集成。想像一下，使用一个像 Ansible 这样的自动化平台，并且，你选择的网络供应商发布了你 *真正* 需要的一个自动化的新特性。从理论上说，网络供应商或者 Ansible 可以发行一个新的插件去实现自动化这个独特的特性，这是一件非常好的事情，从你的内部工程师到你的增值分销商（VAR）或者你的顾问中的任何一个人，都可以去提供这种集成。
正如前面所说的那样，Ansible 实际上是极具扩展性的，Ansible 最初就是为自动化应用程序和系统构建的。这是因为，Ansible 的可扩展性来自于其集成性是为网络供应商编写的，包括但不限于 Cisco、Arista、Juniper、F5、HP、A10、Cumulus 和 Palo Alto Networks。
### 对于网络自动化，为什么要使用 Ansible？
我们已经简单了解除了 Ansible 是什么，以及一些网络自动化的好处，但是，对于网络自动化，我们为什么要使用 Ansible？
大家很清楚，使得 Ansible 成为如此伟大的一个自动化应用部署平台的许多原因已经被大家所提及了。但是，我们现在要深入一些，更多地关注于网络，并且继续总结一些更需要注意的其它关键点。
#### 无代理
在实现网络自动化的时候，无代理架构的重要性并不是重点强调的，特别是当它适用于现有的自动化设备时。如果，我们看一下当前网络中已经安装的各种设备时，从 DMZ 和园区，到分支机构和数据中心，最大份额的设备 *并不* 具有最新 API 的设备。从自动化的角度来看，API 可以使做一些事情变得很简单，像 Ansible 这样的无代理平台有可能去自动化和管理那些 *老旧（传统）* 的设备。例如，*基于 CLI 的设备*，它的工具可以被用于任何网络环境中。
>
> 注意：
>
>
> 如果仅支持 CLI 的设备已经集成进 Ansible，它的机制就像是，怎么在设备上通过协议如 telnet、SSH 和 SNMP 去进行只读访问和读写操作。
>
>
>
作为一个独立的网络设备，像路由器、交换机、和防火墙正在持续去增加 API 的支持，SDN 解决方案也正在出现。SDN 解决方案的其中一个常见主题是，它们都提供一个单点集成和策略管理，通常是以一个 SDN 控制器的形式出现。这对于 Cisco ACI、VMware NSX、Big Switch Big Cloud Fabric 和 Juniper Contrail，以及其它的 SDN 提供者，比如 Nuage、Plexxi、Plumgrid、Midokura 和 Viptela，是一个真实的解决方案。这甚至包含开源的控制器，比如 OpenDaylight。
所有的这些解决方案都简化了网络管理，就像它们可以让一个管理员开始从“box-by-box”管理（LCTT 译者注：指的是单个设备挨个去操作的意思）迁移到网络范围的管理。这是在正确方向上迈出的很大的一步，这些解决方案并不能消除在变更期间中人类犯错的机率。例如，比起配置 *N* 个交换机，你可能需要去配置一个单个的 GUI，它需要很长的时间才能实现所需要的配置改变 —— 它甚至可能更复杂，毕竟，相对于一个 CLI，他们更喜欢 GUI！另外，你可能有不同类型的 SDN 解决方案部署在每个应用程序、网络、区域或者数据中心。
在需要自动化的网络中，对于配置管理、监视和数据收集，当行业开始向基于控制器的网络架构中迁移时，这些需求并不会消失。
大量的软件定义网络中都部署有控制器，几乎所有的控制器都<ruby> 提供 <rt> expose </rt></ruby>一个最新的 REST API。并且，因为 Ansible 是一个无代理架构，它实现自动化是非常简单的，而不仅仅是对那些没有 API 的传统设备，但也有通过 REST API 的软件定义网络解决方案，在所有的终端上不需要有额外的软件（LCTT 译注：指的是代理）。最终的结果是，使用 Ansible，无论有或没有 API，可以使任何类型的设备都能够自动化。
#### 自由开源软件（FOSS)
Ansible 是一个开源软件，它的全部代码在 GitHub 上都是公开可访问的，使用 Ansible 是完全免费的。它可以在几分钟内完成安装并为网络工程师提供有用的价值。Ansible 这个开源项目，或者 Ansible 公司，在它们交付软件之前，你不会遇到任何一个销售代表。那是显而易见的事实，因为它是一个真正的开源项目，但是，作为开源的、社区驱动的软件项目在网络行业中的使用是非常少的，但是，也在逐渐增加，我们想明确指出这一点。
同样需要指出的一点是，Ansible, Inc. 也是一个公司，它也需要去赚钱，对吗？虽然 Ansible 是开源的，它也有一个叫 Ansible Tower 的企业产品，它增加了一些特性，比如，基于规则的访问控制（RBAC）、报告、 web UI、REST API、多租户等等，（相比 Ansible）它更适合于企业去部署。并且，更重要的是，Ansible Tower 甚至可以最多在 10 台设备上 *免费* 使用，至少，你可以去体验一下，它是否会为你的组织带来好处，而无需花费一分钱，并且，也不需要与无数的销售代表去打交道。
#### 可扩展性
我们在前面说过，Ansible 主要是为部署 Linux 应用程序而构建的自动化平台，虽然从早期开始已经扩展到 Windows。需要指出的是，Ansible 开源项目并没有“自动化网络基础设施”的目标。事实上是，Ansible 社区更明白如何在底层的 Ansible 架构上更具灵活性和可扩展性，对于他们的自动化需要（包括网络）更容易成为一个 *扩展* 的 Ansible。在过去的两年中，部署有许多的 Ansible 集成，许多是有行业独立人士进行的，比如，Matt Oswalt、Jason Edelman、Kirk Byers、Elisa Jasinska、David Barroso、Michael Ben-Ami、Patrick Ogenstad 和 Gabriele Gerbino，也有网络系统供应商的领导者，比如，Arista、Juniper、Cumulus、Cisco、F5、和 Palo Alto Networks。
#### 集成到已存在的 DevOps 工作流中
Ansible 在 IT 组织中被用于应用程序部署。它被用于需要管理部署、监视和管理各种类型的应用程序的运维团队中。通过将 Ansible 集成到网络基础设施中，当新应用程序到来或迁移后，它扩展了可能的范围。而不是去等待一个新的顶架交换机（LCTT 译注：TOR，一种数据中心设备接入的方式）的到来、去添加一个 VLAN、或者去检查接口的速度/双工，所有的这些以网络为中心的任务都可以被自动化，并且可以集成到 IT 组织内已经存在的工作流中。
#### 幂等性
术语<ruby> 幂等性 <rt> idempotency </rt></ruby> （读作 item-potency）经常用于软件开发的领域中，尤其是当使用 REST API 工作的时候，以及在 *DevOps* 自动化和配置管理框架的领域中，包括 Ansible。Ansible 的其中一个信念是，所有的 Ansible 模块（集成的）应该是幂等的。那么，对于一个模块来说，幂等是什么意思呢？毕竟，对大多数网络工程师来说，这是一个新的术语。
答案很简单。幂等性的本质是允许定义的任务，运行一次或者上千次都不会在目标系统上产生不利影响，仅仅是一种一次性的改变。换句话说，如果有一个要做的改变去使系统进入到它期望的状态，这种改变完成之后，并且，如果这个设备已经达到这种状态，就不会再发生改变。这不像大多数传统的定制脚本和拷贝、黏贴到那些终端窗口中的 CLI 命令。当相同的命令或者脚本在同一个系统上重复运行，（有时候）会出现错误。即使是粘贴一组命令到一个路由器中，也可能会遇到一些使你的其余的配置失效的错误。好玩吧?
另外的例子是，如果你有一个配置 10 个 VLAN 的文件文件或者脚本，那么 *每次* 运行这个脚本，相同的命令命令会被输入 10 次。如果使用一个幂等的 Ansible 模块，首先会从网络设备中采集已存在的配置，并且，每个新的 VLAN 被配置后会再次检查当前配置。仅仅当这个新的 VLAN 需要被添加（或者，比如说改变 VLAN 名字）是一个变更，命令才会真实地推送到设备。
当一个技术越来越复杂，幂等性的价值就越高，在你修改的时候，你并不能注意到 *已存在* 的网络设备的状态，而仅仅是从一个网络配置和策略角度去尝试达到 *期望的* 状态。
#### 网络范围的和临时（Ad Hoc）的改变
用配置管理工具解决的其中一个问题是，配置“飘移”（当设备的期望配置逐渐漂移，或者改变，随着时间的推移，手动改变和/或在一个环境中使用了多个不同的工具），事实上，这也是像 Puppet 和 Chef 所使用的地方。代理商<ruby> 电联 <rt> phone home </rt></ruby>到前端服务器，验证它的配置，并且，如果需要变更，则改变它。这个方法是非常简单的。如果有故障了，需要去排除怎么办？你通常需要跳过管理系统，直接连到设备，找到并修复它，然后，马上离开，对不对？果然，在下次当代理电连回来，这个修复问题的改变被覆盖了（基于主/前端服务器是怎么配置的）。在高度自动化的环境中，一次性的改变应该被限制，但是，仍然允许使用它们（LCTT 译注：指的是一次性改变）的工具是非常有价值的。正如你想到的，其中一个这样的工具是 Ansible。
因为 Ansible 是无代理的，这里并没有一个默认的推送或者拉取去防止配置漂移。自动化任务被定义在 Ansible <ruby剧本playbook中，当使用 Ansible 时，它让用户去运行剧本。如果剧本在一个给定的时间间隔内运行，并且你没有用 Ansible Tower，你肯定知道任务的执行频率；如果你只是在终端提示符下使用一个原生的 Ansible 命令行，那么该剧本就运行一次，并且仅运行一次。
缺省运行一次的剧本对网络工程师是很具有吸引力的，让人欣慰的是，在设备上手动进行的改变不会自动被覆盖。另外，当需要的时候，一个剧本所运行的设备范围很容易被改变，即使是对一个单个设备进行自动化的单次变更，Ansible 仍然可以用，设备的 *范围* 由一个被称为 Ansible <ruby> 清单 <rt> inventory </rt></ruby>的文件决定；这个清单可以是一台设备或者是一千台设备。
下面展示的一个清单文件示例，它定义了两组共六台设备：
```
[core-switches]
dc-core-1
dc-core-2
[leaf-switches]
leaf1
leaf2
leaf3
leaf4
```
为了自动化所有的主机，你的剧本中的<ruby> 剧集 <rt> play </rt></ruby>定义的一个片段看起来应该是这样的：
```
hosts: all
```
并且，要只自动化一个叶子节点交换机，它看起来应该像这样：
```
hosts: leaf1
```
这是一个核心交换机：
```
hosts: core-switches
```
>
> 注意
>
>
> 正如前面所说的那样，这个报告的后面部分将详细介绍剧本、剧集、和清单。
>
>
>
因为能够很容易地对一台设备或者 *N* 台设备进行自动化，所以在需要对这些设备进行一次性变更时，Ansible 成为了最佳的选择。在网络范围内的变更它也做的很好：可以是关闭给定类型的所有接口、配置接口描述、或者是在一个跨企业园区布线的网络中添加 VLAN。
### 使用 Ansible 实现网络任务自动化
这个报告从两个方面逐渐深入地讲解一些技术。第一个方面是围绕 Ansible 架构和它的细节，第二个方面是，从一个网络的角度，讲解使用 Ansible 可以完成什么类型的自动化。在这一章中我们将带你去详细了解第二方面的内容。
自动化一般被认为是速度快，但是，考虑到一些任务并不要求速度，这就是为什么一些 IT 团队没有认识到自动化的价值所在。VLAN 配置是一个非常好的例子，因为，你可能会想，“创建一个 VLAN 到底有多快？一般情况下每天添加多少个 VLAN？我真的需要自动化吗？”
在这一节中，我们专注于另外几种有意义的自动化任务，比如，设备准备、数据收集、报告和遵从情况。但是，需要注意的是，正如我们前面所说的，自动化为你、你的团队、以及你的精确的更可预测的结果和更多的确定性，提供了更快的速度和敏捷性。
#### 设备准备
为网络自动化开始使用 Ansible 的最容易也是最快的方法是，为设备的最初投入使用创建设备配置文件，并且将配置文件推送到网络设备中。
如果我们去完成这个过程，它将分解为两步，第一步是创建一个配置文件，第二步是推送这个配置到设备中。
首先，我们需要去从供应商配置文件的底层专用语法（CLI）中解耦 *输入*。这意味着我们需要对配置参数中分离出文件和值，比如，VLAN、域信息、接口、路由、和其它的内容等等，然后，当然是一个配置的模块文件。在这个示例中，这里有一个标准模板，它可以用于所有设备的初始部署。Ansible 将帮助提供配置模板中需要的输入和值之间的部分。几秒钟之内，Ansible 可以生成数百个可靠的和可预测的配置文件。
让我们快速的看一个示例，它使用当前的配置，并且分解它到一个模板和单独的一个（作为一个输入源的）变量文件中。
这是一个配置文件片断的示例：
```
hostname leaf1
ip domain-name ntc.com
!
vlan 10
name web
!
vlan 20
name app
!
vlan 30
name db
!
vlan 40
name test
!
vlan 50
name misc
```
如果我们提取输入值，这个文件将被转换成一个模板。
>
> 注意：
>
>
> Ansible 使用基于 Python 的 Jinja2 模板化语言，因此，这个被命名为 *leaf.j2* 的文件是一个 Jinja2 模板。
>
>
>
注意，下列的示例中，*双大括号（`{{}}`）* 代表一个变量。
模板看起来像这些，并且给它命名为 `leaf.j2`：
```
!
hostname {{ inventory_hostname }}
ip domain-name {{ domain_name }}
!
!
{% for vlan in vlans %}
vlan {{ vlan.id }}
name {{ vlan.name }}
{% endfor %}
!
```
因为双大括号代表变量，并且，我们看到这些值并不在模板中，所以它们需要将值保存在一个地方。值被保存在一个变量文件中。正如前面所说的，一个相应的变量文件看起来应该是这样的：
```
---
hostname: leaf1
domain_name: ntc.com
vlans:
- { id: 10, name: web }
- { id: 20, name: app }
- { id: 30, name: db }
- { id: 40, name: test }
- { id: 50, name: misc }
```
这意味着，如果管理 VLAN 的团队希望在网络设备中添加一个 VLAN，很简单，他们只需要在变量文件中改变它，然后，使用 Ansible 中一个叫 `template` 的模块，去重新生成一个新的配置文件。这整个过程也是幂等的；仅仅是在模板或者值发生改变时，它才会去生成一个新的配置文件。
一旦配置文件生成，它需要去 *推送* 到网络设备。推送配置文件到网络设备使用一个叫做 `napalm_install_config`的开源的 Ansible 模块。
接下来的示例是一个 *构建并推送* 一个配置文件到网络设备的简单剧本。同样地，该剧本使用一个名叫 `template` 的模块去构建配置文件，然后使用一个名叫 `napalm_install_config` 的模块去推送它们，并且激活它作为设备上运行的新的配置文件。
虽然没有详细解释示例中的每一行，但是，你仍然可以看明白它们实际上做了什么。
>
> 注意：
>
>
> 下面的剧本介绍了新的概念，比如，内置变量 `inventory_hostname`。这些概念包含在 [Ansible 术语和入门](https://www.oreilly.com/learning/network-automation-with-ansible#ansible_terminology_and_getting_started) 中。
>
>
>
```
---
- name: BUILD AND PUSH NETWORK CONFIGURATION FILES
hosts: leaves
connection: local
gather_facts: no
tasks:
- name: BUILD CONFIGS
template:
src=templates/leaf.j2
dest=configs/{{inventory_hostname }}.conf
- name: PUSH CONFIGS
napalm_install_config:
hostname={{ inventory_hostname }}
username={{ un }}
password={{ pwd }}
dev_os={{ os }}
config_file=configs/{{ inventory_hostname }}.conf
commit_changes=1
replace_config=0
```
这个两步的过程是一个使用 Ansible 进行网络自动化入门的简单方法。通过模板简化了你的配置，构建配置文件，然后，推送它们到网络设备 — 因此，被称为 `BUILD` 和 `PUSH` 方法。
>
> 注意：
>
>
> 像这样的更详细的例子，请查看 [Ansible 网络集成](https://www.oreilly.com/learning/network-automation-with-ansible#ansible_network_integrations)。
>
>
>
#### 数据收集和监视
监视工具一般使用 SNMP —— 这些工具拉取某些管理信息库（MIB），然后给监视工具返回数据。基于返回的数据，它可能多于也可能少于你真正所需要的数据。如果接口基于返回的数据统计你正在拉取的内容，你可能会返回在 `show interface` 命令中显示的计数器。如果你仅需要 `interface resets` 并且，希望去看到与重置相关的邻接 CDP/LLDP 的接口，那该怎么做呢？当然，这也可以使用当前的技术；可以运行多个显示命令去手动解析输出信息，或者，使用基于 SNMP 的工具，在 GUI 中切换不同的选项卡（Tab）找到真正你所需要的数据。Ansible 怎么能帮助我们去完成这些工作呢？
由于 Ansible 是完全开源并且是可扩展的，它可以精确地去收集和监视所需要的计数器或者值。这可能需要一些预先的定制工作，但是，最终这些工作是非常有价值的。因为采集的数据是你所需要的，而不是供应商提供给你的。Ansible 也提供了执行某些条件任务的直观方法，这意味着基于正在返回的数据，你可以执行子任务，它可以收集更多的数据或者产生一个配置改变。
网络设备有 *许多* 统计和隐藏在里面的临时数据，而 Ansible 可以帮你提取它们。
你甚至可以在 Ansible 中使用前面提到的 SNMP 的模块，模块的名字叫 `snmp_device_version`。这是在社区中存在的另一个开源模块：
```
- name: GET SNMP DATA
snmp_device_version:
host=spine
community=public
version=2c
```
运行前面的任务返回非常多的关于设备的信息，并且添加一些级别的发现能力到 Ansible中。例如，那个任务返回下列的数据：
```
{"ansible_facts": {"ansible_device_os": "nxos", "ansible_device_vendor": "cisco", "ansible_device_version": "7.0(3)I2(1)"}, "changed": false}
```
你现在可以决定某些事情，而不需要事先知道是什么类型的设备。你所需要知道的仅仅是设备的只读通讯字符串。
#### 迁移
从一个平台迁移到另外一个平台，可能是从同一个供应商或者是从不同的供应商，迁移从来都不是件容易的事。供应商可能提供一个脚本或者一个工具去帮助你迁移。Ansible 可以被用于去为所有类型的网络设备构建配置模板，然后，操作系统用这个方法去为所有的供应商生成一个配置文件，然后作为一个（通用数据模型的）输入设置。当然，如果有供应商专用的扩展，它也是会被用到的。这种灵活性不仅对迁移有帮助，而且也可以用于<ruby> 灾难恢复 <rt> disaster recovery </rt></ruby>（DR），它在生产系统中不同的交换机型号之间和灾备数据中心中是经常使用的，即使是在不同的供应商的设备上。
#### 配置管理
正如前面所说的，配置管理是最常用的自动化类型。Ansible 可以很容易地做到创建<ruby> 角色 <rt> role </rt></ruby>去简化基于任务的自动化。从更高的层面来看，角色是指针对一个特定设备组的可重用的自动化任务的逻辑分组。关于角色的另一种说法是，认为角色就是相关的<ruby> 工作流 <rt> workflow </rt></ruby>。首先，在开始自动化添加值之前，需要理解工作流和过程。不论是开始一个小的自动化任务还是扩展它，理解工作流和过程都是非常重要的。
例如，一组自动化地配置路由器和交换机的任务是非常常见的，并且它们也是一个很好的起点。但是，配置在哪台网络设备上？配置的 IP 地址是什么？或许需要一个 IP 地址管理方案？一旦用一个给定的功能分配了 IP 地址并且已经部署，DNS 也更新了吗？DHCP 的范围需要创建吗？
你可以看到工作流是怎么从一个小的任务开始，然后逐渐扩展到跨不同的 IT 系统？因为工作流持续扩展，所以，角色也一样（持续扩展）。
#### 遵从性
和其它形式的自动化工具一样，用任何形式的自动化工具产生配置改变都被视为风险。手工去产生改变可能看上去风险更大，正如你看到的和亲身经历过的那样，Ansible 有能力去做自动数据收集、监视、和配置构建，这些都是“只读的”和“低风险”的动作。其中一个 *低风险* 使用案例是，使用收集的数据进行配置遵从性检查和配置验证。部署的配置是否满足安全要求？是否配置了所需的网络？协议 XYZ 禁用了吗？因为每个模块、或者用 Ansible 返回数据的整合，它只是非常简单地 *声明* 那些事是 *TRUE* 还是 *FALSE*。然后接着基于 *它* 是 *TRUE* 或者是 *FALSE*， 接着由你决定应该发生什么 —— 或许它只是被记录下来，或者，也可能执行一个复杂操作。
#### 报告
我们现在知道，Ansible 也可以用于去收集数据和执行遵从性检查。Ansible 可以根据你想要做的事情去从设备中返回和收集数据。或许返回的数据成为其它的任务的输入，或者你想去用它创建一个报告。从模板中生成报告，并将真实的数据插入到模板中，创建和使用报告模板的过程与创建配置模板的过程是相同的。
从一个报告的角度看，这些模板或许是纯文本文件，就像是在 GitHub 上看到的 markdown 文件、放置在 Web 服务器上的 HTML 文件，等等。用户有权去创建一个她希望的报告类型，插入她所需要的真实数据到报告中。
创建报告的用处很多，不仅是为行政管理，也为了运营工程师，因为它们通常有双方都需要的不同指标。
### Ansible 怎么工作
从一个网络自动化的角度理解了 Ansible 能做什么之后，我们现在看一下 Ansible 是怎么工作的。你将学习到从一个 Ansible 管理主机到一个被自动化的节点的全部通讯流。首先，我们回顾一下，Ansible 是怎么<ruby> 开箱即用 <rt> out of the box </rt></ruby>的，然后，我们看一下 Ansible 怎么去做到的，具体说就是，当网络设备自动化时，Ansible *模块*是怎么去工作的。
#### 开箱即用
到目前为止，你已经明白了，Ansible 是一个自动化平台。实际上，它是一个安装在一台单个服务器上或者企业中任何一位管理员的笔记本中的轻量级的自动化平台。当然，（安装在哪里？）这是由你来决定的。在基于 Linux 的机器上，使用一些实用程序（比如 pip、apt、和 yum）安装 Ansible 是非常容易的。
>
> 注意：
>
>
> 在本报告的其余部分，安装 Ansible 的机器被称为<ruby> 控制主机 <rt> control host </rt></ruby>。
>
>
>
控制主机将执行定义在 Ansible 的<ruby> 剧本 <rt> playbook </rt></ruby> （不用担心，稍后我们将讲到剧本和其它的 Ansible 术语）中的所有自动化任务。现在，我们只需要知道，一个剧本是简单的一组自动化任务和在给定数量的主机上执行的指令。
当一个剧本创建之后，你还需要去定义它要自动化的主机。映射一个剧本和要自动化运行的主机，是通过一个被称为 Ansible <ruby> 清单 <rt> inventory </rt></ruby>的文件。这是一个前面展示的示例，但是，这里是同一个清单文件的另外两个组：`cisco` 和 `arista`：
```
[cisco]
nyc1.acme.com
nyc2.acme.com
[arista]
sfo1.acme.com
sfo2.acme.com
```
>
> 注意：
>
>
> 你也可以在清单文件中使用 IP 地址，而不是主机名。对于这样的示例，主机名将是通过 DNS 可解析的。
>
>
>
正如你所看到的，Ansible 清单文件是一个文本文件，它列出了主机和主机组。然后，你可以在剧本中引用一个具体的主机或者组，以此去决定对给定的<ruby> 剧集 <rt> play </rt></ruby>和剧本在哪台主机上进行自动化。下面展示了两个示例。
展示的第一个示例它看上去像是，你想去自动化 `cisco` 组中所有的主机，而展示的第二个示例只对 `nyc1.acme.com` 主机进行自动化：
```
---
- name: TEST PLAYBOOK
hosts: cisco
tasks:
- TASKS YOU WANT TO AUTOMATE
```
```
---
- name: TEST PLAYBOOK
hosts: nyc1.acme.com
tasks:
- TASKS YOU WANT TO AUTOMATE
```
现在，我们已经理解了基本的清单文件，我们可以看一下（在控制主机上的）Ansible 是怎么与 *开箱即用* 的设备通讯的，和在 Linux 终端上自动化的任务。这里需要明白一个重要的观点就是，需要去自动化的网络设备通常是不一样的。（LCTT 译注：指的是设备的类型、品牌、型号等等）
Ansible 对基于 Linux 的系统去开箱即用自动化工作有两个要求。它们是 SSH 和 Python。
首先，终端必须支持 SSH 传输，因为 Ansible 使用 SSH 去连接到每个目标节点。因为 Ansible 支持一个可拔插的连接架构，也有各种类型的插件去实现不同类型的 SSH。
第二个要求是，Ansible 并不要求在目标节点上预先存在一个 *代理*，Ansible 并不要求一个软件代理，它仅需要一个内置的 Python 执行引擎。这个执行引擎用于去执行从 Ansible 管理主机发送到被自动化的目标节点的 Python 代码。
如果我们详细解释这个开箱即用工作流，它将分解成如下的步骤：
1. 当执行一个 Ansible 剧集时，控制主机使用 SSH 连接到基于 Linux 的目标节点。
2. 对于每个任务，也就是说，Ansible 模块将在这个剧集中被执行，通过 SSH 发送 Python 代码并直接在远程系统中执行。
3. 在远程系统上运行的每个 Ansible 模块将返回 JSON 数据到控制主机。这些数据包含有信息，比如，配置改变、任务成功/失败、以及其它模块特定的数据。
4. JSON 数据返回给 Ansible，然后被用于去生成报告，或者被用作接下来模块的输入。
5. 在剧集中为每个任务重复第 3 步。
6. 在剧本中为每个剧集重复第 1 步。
是不是意味着每个网络设备都可以被 Ansible 开箱即用？因为它们也都支持 SSH，确实，网络设备都支持 SSH，但是，第一个和第二要求的组合限制了网络设备可能的功能。
刚开始时，大多数网络设备并不支持 Python，因此，使用默认的 Ansible 连接机制是无法进行的。换句话说，在过去的几年里，供应商在几个不同的设备平台上增加了 Python 支持。但是，这些平台中的大多数仍然缺乏必要的集成，以允许 Ansible 去直接通过 SSH 访问一个 Linux shell，并以适当的权限去拷贝所需的代码、创建临时目录和文件、以及在设备中执行代码。尽管 Ansible 中所有的这些部分都可以在基于 Linux 的网络设备上使用 SSH/Python 在本地运行，它仍然需要网络设备供应商去更进一步开放他们的系统。
>
> 注意：
>
>
> 值的注意的是，Arista 确实也提供了原生的集成，因为它可以无需 SSH 用户，直接进入到一个 Linux shell 中访问 Python 引擎，它可以允许 Ansible 去使用其默认连接机制。因为我们调用了 Arista，我们也需要着重强调与 Ansible 默认连接机制一起工作的 Cumulus。这是因为 Cumulus Linux 是原生 Linux，并且它并不需要为 Cumulus Linux 操作系统使用供应商 API。
>
>
>
#### Ansible 网络集成
前面的节讲到过 Ansible 默认的工作方式。我们看一下，在开始一个 *剧集* 之后，Ansible 是怎么去设置一个到设备的连接、通过拷贝 Python 代码到设备、运行代码、和返回结果给 Ansible 控制主机来执行任务。
在这一节中，我们将看一看，当使用 Ansible 进行自动化网络设备时都做了什么。正如前面讲过的，Ansible 是一个可拔插的连接架构。对于 *大多数* 的网络集成， `connection` 参数设置为 `local`。在剧本中大多数的连接类型都设置为 `local`，如下面的示例所展示的：
```
---
- name: TEST PLAYBOOK
hosts: cisco
connection: local
tasks:
- TASKS YOU WANT TO AUTOMATE
```
注意在剧集中是怎么定义的，这个示例增加 `connection` 参数去和前面节中的示例进行比较。
这告诉 Ansible 不要通过 SSH 去连接到目标设备，而是连接到本地机器运行这个剧本。基本上，这是把连接职责委托给剧本中<ruby> 任务 <rt> task </rt></ruby> 节中使用的真实的 Ansible 模块。每个模块类型的委托权利允许这个模块在必要时以各种形式去连接到设备。这可能是 Juniper 和 HP Comware7 的 NETCONF、Arista 的 eAPI、Cisco Nexus 的 NX-API、或者甚至是基于传统系统的 SNMP，它们没有可编程的 API。
>
> 注意：
>
>
> 网络集成在 Ansible 中是以 Ansible 模块的形式带来的。尽管我们持续使用术语来吊你的胃口，比如，剧本、剧集、任务、和讲到的关键概念模块，这些术语中的每一个都会在 [Ansible 术语和入门](https://www.oreilly.com/learning/network-automation-with-ansible#ansible_terminology_and_getting_started) 和 [动手实践使用 Ansible 去进行网络自动化](https://www.oreilly.com/learning/network-automation-with-ansible#handson_look_at_using_ansible_for_network_automation) 中详细解释。
>
>
>
让我们看一看另外一个剧本的示例：
```
---
- name: TEST PLAYBOOK
hosts: cisco
connection: local
tasks:
- nxos_vlan: vlan_id=10 name=WEB_VLAN
```
你注意到了吗，这个剧本现在包含一个任务，并且这个任务使用了 `nxos_vlan` 模块。`nxos_vlan` 模块是一个 Python 文件，并且，在这个文件中它是使用 NX-API 连接到 Cisco 的 NX-OS 设备。可是，这个连接可能是使用其它设备 API 设置的，这就是为什么供应商和用户像我们这样能够去建立自己的集成的原因。集成（模块）通常是以<ruby> 每特性 <rt> per-feature </rt></ruby>为基础完成的，虽然，你已经看到了像 `napalm_install_config` 这样的模块，它们也可以被用来 *推送* 一个完整的配置文件。
主要区别之一是使用的默认连接机制，Ansible 启动一个持久的 SSH 连接到设备，并且对于一个给定的剧集而已该连接将持续存在。当在一个模块中发生连接设置和拆除时，与许多使用 `connection=local` 的网络模块一样，对发生在剧集级别上的 *每个* 任务，Ansible 将登入/登出设备。
而在传统的 Ansible 形式下，每个网络模块返回 JSON 数据。仅有的区别是相对于目标节点，数据的推取发生在本地的 Ansible 控制主机上。相对于<ruby> 每供应商 <rt> per vendor </rt></ruby>和模块类型，数据返回到剧本，但是作为一个示例，许多的 Cisco NX-OS 模块返回已存在的状态、建议状态、和最终状态，以及发送到设备的命令（如果有的话）。
作为使用 Ansible 进行网络自动化的开始，最重要的是，为 Ansible 的连接设备/拆除过程，记着去设置连接参数为 `local`，并且将它留在模块中。这就是为什么模块支持不同类型的供应商平台，它将与设备使用不同的方式进行通讯。
### Ansible 术语和入门
这一章我们将介绍许多 Ansible 的术语和报告中前面部分出现过的关键概念。比如， <ruby> 清单文件 <rt> inventory file </rt></ruby>、<ruby> 剧本 <rt> playbook </rt></ruby>、<ruby> 剧集 <rt> play </rt></ruby>、<ruby> 任务 <rt> task </rt></ruby>和<ruby> 模块 <rt> module </rt></ruby>。我们也会去回顾一些其它的概念，这些术语和概念对我们学习使用 Ansible 去进行网络自动化非常有帮助。
在这一节中，我们将引用如下的一个简单的清单文件和剧本的示例，它们将在后面的章节中持续出现。
*清单示例* ：
```
# sample inventory file
# filename inventory
[all:vars]
user=admin
pwd=admin
[tor]
rack1-tor1 vendor=nxos
rack1-tor2 vendor=nxos
rack2-tor1 vendor=arista
rack2-tor2 vendor=arista
[core]
core1
core2
```
*剧本示例* ：
```
---
# sample playbook
# filename site.yml
- name: PLAY 1 - Top of Rack (TOR) Switches
hosts: tor
connection: local
tasks:
- name: ENSURE VLAN 10 EXISTS ON CISCO TOR SWITCHES
nxos_vlan:
vlan_id=10
name=WEB_VLAN
host={{ inventory_hostname }}
username=admin
password=admin
when: vendor == "nxos"
- name: ENSURE VLAN 10 EXISTS ON ARISTA TOR SWITCHES
eos_vlan:
vlanid=10
name=WEB_VLAN
host={{ inventory_hostname }}
username={{ user }}
password={{ pwd }}
when: vendor == "arista"
- name: PLAY 2 - Core (TOR) Switches
hosts: core
connection: local
tasks:
- name: ENSURE VLANS EXIST IN CORE
nxos_vlan:
vlan_id={{ item }}
host={{ inventory_hostname }}
username={{ user }}
password={{ pwd }}
with_items:
- 10
- 20
- 30
- 40
- 50
```
#### 清单文件
使用一个清单文件，比如前面提到的那个，允许我们去为自动化任务指定主机、和使用每个剧集顶部节中（如果存在）的参数 `hosts` 所引用的主机/组指定的主机组。
它也可能在一个清单文件中存储变量。如这个示例中展示的那样。如果变量在同一行视为一台主机，它是一个具体主机变量。如果变量定义在方括号中（`[ ]`），比如，`[all:vars]`，它的意思是指变量在组中的范围 `all`，它是一个默认组，包含了清单文件中的 *所有* 主机。
>
> 注意：
>
>
> 清单文件是使用 Ansible 开始自动化的快速方法，但是，你应该已经有一个真实的网络设备源，比如一个网络管理工具或者 CMDB，它可以去创建和使用一个动态的清单脚本，而不是一个静态的清单文件。
>
>
>
#### 剧本
剧本是去运行自动化网络设备的顶级对象。在我们的示例中，它是 `site.yml` 文件，如前面的示例所展示的。一个剧本使用 YAML 去定义一组自动化任务，并且，每个剧本由一个或多个剧集组成。这类似于一个橄榄球的剧本。就像在橄榄球赛中，团队有剧集组成的剧本，Ansible 的剧本也是由剧集组成的。
>
> 注意：
>
>
> YAML 是一种被所有编程语言支持的数据格式。YAML 本身就是 JSON 的超集，并且，YAML 文件非常易于识别，因为它总是三个破折号（连字符）开始，比如，`---`。
>
>
>
#### 剧集
一个 Ansible 剧本可以存在一个或多个剧集。在前面的示例中，它在剧本中有两个剧集。每个剧集开始的地方都有一个 *头部*，它定义了具体的参数。
示例中两个剧集都定义了下面的参数：
`name`
文件 `PLAY 1 - Top of Rack (TOR) Switches` 是任意内容的，它在剧本运行的时候，去改善剧本运行和报告期间的可读性。这是一个可选参数。
`hosts`
正如前面讲过的，这是在特定的剧集中要去进行自动化的主机或主机组。这是一个必需参数。
`connection`
正如前面讲过的，这是剧集连接机制的类型。这是个可选参数，但是，对于网络自动化剧集，一般设置为 `local`。
每个剧集都是由一个或多个任务组成。
#### 任务
任务是以声明的方式去表示自动化的内容，而不用担心底层的语法或者操作是怎么执行的。
在我们的示例中，第一个剧集有两个任务。每个任务确保存在 10 个 VLAN。第一个任务是为 Cisco Nexus 设备的，而第二个任务是为 Arista 设备的：
```
tasks:
- name: ENSURE VLAN 10 EXISTS ON CISCO TOR SWITCHES
nxos_vlan:
vlan_id=10
name=WEB_VLAN
host={{ inventory_hostname }}
username=admin
password=admin
when: vendor == "nxos"
```
任务也可以使用 `name` 参数，就像剧集一样。和剧集一样，文本内容是任意的，并且当剧本运行时显示，去改善剧本运行和报告期间的可读性。它对每个任务都是可选参数。
示例任务中的下一行是以 `nxos_vlan` 开始的。它告诉我们这个任务将运行一个叫 `nxos_vlan` 的 Ansible 模块。
现在，我们将进入到模块中。
#### 模块
在 Ansible 中理解模块的概念是至关重要的。虽然任何编辑语言都可以用来写 Ansible 模块，只要它们能够返回 JSON 键/值对即可，但是，几乎所有的模块都是用 Python 写的。在我们示例中，我们看到有两个模块被运行： `nxos_vlan` 和 `eos_vlan`。这两个模块都是 Python 文件；而事实上，在你不能看到剧本的时候，真实的文件名分别是 `eos_vlan.py` 和 `nxos_vlan.py`。
让我们看一下前面的示例中第一个剧集中的第一个任务：
```
- name: ENSURE VLAN 10 EXISTS ON CISCO TOR SWITCHES
nxos_vlan:
vlan_id=10
name=WEB_VLAN
host={{ inventory_hostname }}
username=admin
password=admin
when: vendor == "nxos"
```
这个任务运行 `nxos_vlan`，它是一个自动配置 VLAN 的模块。为了使用这个模块，包含它，你需要为设备指定期望的状态或者配置策略。这个示例中的状态是：VLAN 10 将被配置一个名字 `WEB_VLAN`，并且，它将被自动配置到每个交换机上。我们可以看到，使用 `vlan_id` 和 `name` 参数很容易做到。模块中还有三个其它的参数，它们分别是：`host`、`username`、和 `password`：
`host`
这是将要被自动化的主机名（或者 IP 地址）。因为，我们希望去自动化的设备已经被定义在清单文件中，我们可以使用内置的 Ansible 变量 `inventory_hostname`。这个变量等价于清单文件中的内容。例如，在第一个循环中，在清单文件中的主机是 `rack1-tor1`，然后，在第二个循环中，它是 `rack1-tor2`。这些名字是进入到模块的，并且包含在模块中的，在每个名字到 IP 地址的解析中，都发生一个 DNS 查询。然后与这个设备进行通讯。
`username`
用于登入到交换机的用户名。
`password`
用于登入到交换机的密码。
示例中最后的片断部分使用了一个 `when` 语句。这是在一个剧集中使用的 Ansible 的执行条件任务。正如我们所了解的，在这个剧集的 `tor` 组中有多个设备和设备类型。使用 `when` 基于任意标准去提供更多的选择。这里我们仅自动化 Cisco 设备，因为，我们在这个任务中使用了 `nxos_vlan` 模块，在下一个任务中，我们仅自动化 Arista 设备，因为，我们使用了 `eos_vlan` 模块。
>
> 注意：
>
>
> 这并不是区分设备的唯一方法。这里仅是演示如何使用 `when`，并且可以在清单文件中定义变量。
>
>
>
在清单文件中定义变量是一个很好的开端，但是，如果你继续使用 Ansible，你将会为了扩展性、版本控制、对给定文件的改变最小化而去使用基于 YAML 的变量。这也将简化和改善清单文件和每个使用的变量的可读性。在设备准备的构建/推送方法中讲过一个变量文件的示例。
在最后的示例中，关于任务有几点需要去搞清楚：
* 剧集 1 任务 1 展示了硬编码了 `username` 和 `password` 作为参数进入到具体的模块中（`nxos_vlan`）。
* 剧集 1 任务 1 和 剧集 2 在模块中使用了变量，而不是硬编码它们。这掩饰了 `username` 和 `password` 参数，但是，需要值得注意的是，（在这个示例中）这些变量是从清单文件中提取出现的。
* 剧集 1 中为进入到模块中的参数使用了一个 *水平的* 的 key=value 语法，虽然剧集 2 使用了垂直的 key=value 语法。它们都工作的非常好。你也可以使用垂直的 YAML “key: value” 语法。
* 最后的任务也介绍了在 Ansible 中怎么去使用一个循环。它通过使用 `with_items` 来完成，并且它类似于一个 for 循环。那个特定的任务是循环进入五个 VLAN 中去确保在交换机中它们都存在。注意：它也可能被保存在一个外部的 YAML 变量文件中。还需要注意的一点是，不使用 `with_items` 的替代方案是，每个 VLAN 都有一个任务 —— 如果这样做，它就失去了弹性！
### 动手实践使用 Ansible 去进行网络自动化
在前面的章节中，提供了 Ansible 术语的一个概述。它已经覆盖了大多数具体的 Ansible 术语，比如剧本、剧集、任务、模块和清单文件。这一节将继续提供示例去讲解使用 Ansible 实现网络自动化，而且将提供在不同类型的设备中自动化工作的模块的更多细节。示例中的将要进行自动化设备由多个供应商提供，包括 Cisco、Arista、Cumulus、和 Juniper。
在本节中的示例，假设的前提条件如下：
* Ansible 已经安装。
* 在设备中（NX-API、eAPI、NETCONF）适合的 APIs 已经启用。
* 用户在系统上有通过 API 去产生改变的适当权限。
* 所有的 Ansible 模块已经在系统中存在，并且也在库的路径变量中。
>
> 注意：
>
>
> 可以在 `ansible.cfg` 文件中设置模块和库路径。在你运行一个剧本时，你也可以使用 `-M` 标志从命令行中去改变它。
>
>
>
在本节中示例使用的清单如下。（删除了密码，IP 地址也发生了变化）。在这个示例中，（和前面的示例一样）某些主机名并不是完全合格域名（FQDN）。
#### 清单文件
```
[cumulus]
cvx ansible_ssh_host=1.2.3.4 ansible_ssh_pass=PASSWORD
[arista]
veos1
[cisco]
nx1 hostip=5.6.7.8 un=USERNAME pwd=PASSWORD
[juniper]
vsrx hostip=9.10.11.12 un=USERNAME pwd=PASSWORD
```
>
> 注意：
>
>
> 正如你所知道的，Ansible 支持将密码存储在一个加密文件中的功能。如果你想学习关于这个特性的更多内容，请查看在 Ansible 网站上的文档中的 [Ansible Vault](http://docs.ansible.com/ansible/playbooks_vault.html) 部分。
>
>
>
这个清单文件有四个组，每个组定义了一台单个的主机。让我们详细回顾一下每一节：
**Cumulus**
主机 `cvx` 是一个 Cumulus Linux (CL) 交换机，并且它是 `cumulus` 组中的唯一设备。记住，CL 是原生 Linux，因此，这意味着它是使用默认连接机制（SSH）连到到需要自动化的 CL 交换机。因为 `cvx` 在 DNS 或者 `/etc/hosts` 文件中没有定义，我们将让 Ansible 知道不要在清单文件中定义主机名，而是在 `ansible_ssh_host` 中定义的名字/IP。登陆到 CL 交换机的用户名被定义在 playbook 中，但是，你可以看到密码使用变量 `ansible_ssh_pass` 定义在清单文件中。
**Arista**
被称为 `veos1` 的是一台运行 EOS 的 Arista 交换机。它是在 `arista` 组中唯一的主机。正如你在 Arista 中看到的，在清单文件中并没有其它的参数存在。这是因为 Arista 为它们的设备使用了一个特定的配置文件。在我们的示例中它的名字为 `.eapi.conf`，它存在在 home 目录中。下面是正确使用配置文件的这个功能的示例：
```
[connection:veos1]
host: 2.4.3.4
username: unadmin
password: pwadmin
```
这个文件包含了定义在配置文件中的 Ansible 连接到设备（和 Arista 的被称为 `pyeapi` 的 Python 库）所需要的全部信息。
**Cisco**
和 Cumulus 和 Arista 一样，这里仅有一台主机（`nx1`）存在于 `cisco` 组中。这是一台 NX-OS-based Cisco Nexus 交换机。注意在这里为 `nx1` 定义了三个变量。它们包括 `un` 和 `pwd`，这是为了在 playbook 中访问和为了进入到 Cisco 模块去连接到设备。另外，这里有一个称为 `hostip` 的参数，它是必需的，因为，`nx1` 没有在 DNS 中或者是 `/etc/hosts` 配置文件中定义。
>
> 注意：
>
>
> 如果自动化一个原生的 Linux 设备，我们可以将这个参数命名为任何东西。`ansible_ssh_host` 被用于到如我们看到的那个 Cumulus 示例（如果在清单文件中的定义不能被解析）。在这个示例中，我们将一直使用 `ansible_ssh_host`，但是，它并不是必需的，因为我们将这个变量作为一个参数进入到 Cisco 模块，而 `ansible_ssh_host` 是在使用默认的 SSH 连接机制时自动检查的。
>
>
>
**Juniper**
和前面的三个组和主机一样，在 `juniper` 组中有一个单个的主机 `vsrx`。它在清单文件中的设置与 Cisco 相同，因为两者在 playbook 中使用了相同的方式。
#### 剧本
接下来的剧本有四个不同的剧集。每个剧集是基于特定的供应商类型的设备组的自动化构建的。注意，那是在一个单个的剧本中执行这些任务的唯一的方法。这里还有其它的方法，它可以使用条件（`when` 语句）或者创建 Ansible 角色（它在这个报告中没有介绍）。
这里有一个剧本的示例：
```
---
- name: PLAY 1 - CISCO NXOS
hosts: cisco
connection: local
tasks:
- name: ENSURE VLAN 100 exists on Cisco Nexus switches
nxos_vlan:
vlan_id=100
name=web_vlan
host={{ hostip }}
username={{ un }}
password={{ pwd }}
- name: PLAY 2 - ARISTA EOS
hosts: arista
connection: local
tasks:
- name: ENSURE VLAN 100 exists on Arista switches
eos_vlan:
vlanid=100
name=web_vlan
connection={{ inventory_hostname }}
- name: PLAY 3 - CUMULUS
remote_user: cumulus
sudo: true
hosts: cumulus
tasks:
- name: ENSURE 100.10.10.1 is configured on swp1
cl_interface: name=swp1 ipv4=100.10.10.1/24
- name: restart networking without disruption
shell: ifreload -a
- name: PLAY 4 - JUNIPER SRX changes
hosts: juniper
connection: local
tasks:
- name: INSTALL JUNOS CONFIG
junos_install_config:
host={{ hostip }}
file=srx_demo.conf
user={{ un }}
passwd={{ pwd }}
logfile=deploysite.log
overwrite=yes
diffs_file=junpr.diff
```
你将注意到，前面的两个剧集是非常类似的，我们已经在最初的 Cisco 和 Arista 示例中讲过了。唯一的区别是每个要自动化的组（`cisco` and `arista`) 定义了它们自己的剧集，我们在前面介绍使用 `when` 条件时比较过。
这里有一个不正确的或者是错误的方式去做这些。这取决于你预先知道的信息是什么和适合你的环境和使用的最佳案例是什么，但我们的目的是为了展示做同一件事的几种不同的方法。
第三个剧集是在 Cumulus Linux 交换机的 `swp1` 接口上进行自动化配置。在这个剧集中的第一个任务是去确认 `swp1` 是一个三层接口，并且它配置的 IP 地址是 100.10.10.1。因为 Cumulus Linux 是原生的 Linux，网络服务在改变后需要重启才能生效。这也可以使用 Ansible 的操作来达到这个目的（这已经超出了本报告讨论的范围），这里有一个被称为 `service` 的 Ansible 核心模块来做这些，但它会中断交换机上的网络；使用 `ifreload` 重新启动则不会中断。
本节到现在为止，我们已经讲解了专注于特定任务的 Ansible 模块，比如，配置接口和 VLAN。第四个剧集使用了另外的选项。我们将看到一个 `pushes` 模块，它是一个完整的配置文件并且立即激活它作为正在运行的新的配置。这里将使用 `napalm_install_config` 来展示前面的示例，但是，这个示例使用了一个 Juniper 专用的模块。
`junos_install_config` 模块接受几个参数，如下面的示例中所展示的。到现在为止，你应该理解了什么是 `user`、`passwd`、和 `host`。其它的参数定义如下：
`file`：
这是一个从 Ansible 控制主机拷贝到 Juniper 设备的配置文件。
`logfile`：
这是可选的，但是，如果你指定它，它会被用于存储运行这个模块时生成的信息。
`overwrite`：
当你设置为 yes/true 时，完整的配置将被发送的配置覆盖。（默认是 false）
`diffs_file`：
这是可选的，但是，如果你指定它，当应用配置时，它将存储生成的差异。当应用配置时将存储一个生成的差异。当正好更改了主机名，但是，仍然发送了一个完整的配置文件时会生成一个差异，如下的示例：
```
# filename: junpr.diff
[edit system]
- host-name vsrx;
+ host-name vsrx-demo;
```
上面已经介绍了剧本概述的细节。现在，让我们看看当剧本运行时发生了什么：
>
> 注意：
>
>
> `-i` 标志是用于指定使用的清单文件。也可以设置环境变量 `ANSIBLE_HOSTS`，而不用每次运行剧本时都去使用一个 `-i` 标志。
>
>
>
```
ntc@ntc:~/ansible/multivendor$ ansible-playbook -i inventory demo.yml
PLAY [PLAY 1 - CISCO NXOS] *************************************************
TASK: [ENSURE VLAN 100 exists on Cisco Nexus switches] *********************
changed: [nx1]
PLAY [PLAY 2 - ARISTA EOS] *************************************************
TASK: [ENSURE VLAN 100 exists on Arista switches] **************************
changed: [veos1]
PLAY [PLAY 3 - CUMULUS] ****************************************************
GATHERING FACTS ************************************************************
ok: [cvx]
TASK: [ENSURE 100.10.10.1 is configured on swp1] ***************************
changed: [cvx]
TASK: [restart networking without disruption] ******************************
changed: [cvx]
PLAY [PLAY 4 - JUNIPER SRX changes] ****************************************
TASK: [INSTALL JUNOS CONFIG] ***********************************************
changed: [vsrx]
PLAY RECAP ***************************************************************
to retry, use: --limit @/home/ansible/demo.retry
cvx : ok=3 changed=2 unreachable=0 failed=0
nx1 : ok=1 changed=1 unreachable=0 failed=0
veos1 : ok=1 changed=1 unreachable=0 failed=0
vsrx : ok=1 changed=1 unreachable=0 failed=0
```
你可以看到每个任务成功完成；如果你是在终端上运行，你将看到用琥珀色显示的每个改变的任务。
让我们再次运行 playbook。通过再次运行，我们可以校验所有模块的 *幂等性*；当我们这样做的时候，我们看到设备上 *没有* 产生变化，并且所有的东西都是绿色的：
```
PLAY [PLAY 1 - CISCO NXOS] ***************************************************
TASK: [ENSURE VLAN 100 exists on Cisco Nexus switches] ***********************
ok: [nx1]
PLAY [PLAY 2 - ARISTA EOS] ***************************************************
TASK: [ENSURE VLAN 100 exists on Arista switches] ****************************
ok: [veos1]
PLAY [PLAY 3 - CUMULUS] ******************************************************
GATHERING FACTS **************************************************************
ok: [cvx]
TASK: [ENSURE 100.10.10.1 is configured on swp1] *****************************
ok: [cvx]
TASK: [restart networking without disruption] ********************************
skipping: [cvx]
PLAY [PLAY 4 - JUNIPER SRX changes] ******************************************
TASK: [INSTALL JUNOS CONFIG] *************************************************
ok: [vsrx]
PLAY RECAP ***************************************************************
cvx : ok=2 changed=0 unreachable=0 failed=0
nx1 : ok=1 changed=0 unreachable=0 failed=0
veos1 : ok=1 changed=0 unreachable=0 failed=0
vsrx : ok=1 changed=0 unreachable=0 failed=0
```
注意：这里有 0 个改变，但是，每次运行任务，正如期望的那样，它们都返回 “ok”。说明在这个剧本中的每个模块都是幂等的。
### 总结
Ansible 是一个超级简单的、无代理和可扩展的自动化平台。网络社区持续不断地围绕 Ansible 去重整它作为一个能够执行一些自动化网络任务的平台，比如，做配置管理、数据收集和报告，等等。你可以使用 Ansible 去推送完整的配置文件，配置具体的使用幂等模块的网络资源，比如，接口、VLAN，或者，简单地自动收集信息，比如，领居、序列号、启动时间、和接口状态，以及按你的需要定制一个报告。
因为它的架构，Ansible 被证明是一个在这里可用的、非常好的工具，它可以帮助你实现从传统的基于 *CLI/SNMP* 的网络设备到基于 *API 驱动* 的现代化网络设备的自动化。
在网络社区中，易于使用和无代理架构的 Ansible 的占比持续增加，它将使没有 APIs 的设备（CLI/SNMP）的自动化成为可能。包括独立的交换机、路由器、和 4-7 层的服务应用程序；甚至是提供了 RESTful API 的那些软件定义网络控制器。
当使用 Ansible 实现网络自动化时，不会落下任何设备。
---
作者简介：
Jason Edelman，CCIE 15394 & VCDX-NV 167，出生并成长于新泽西州的一位网络工程师。他是一位典型的 “CLI 爱好者” 和 “路由器小子”。在几年前，他决定更多地关注于软件、开发实践、以及怎么与网络工程融合。Jason 目前经营着一个小的咨询公司，公司名为：Network to Code（<http://networktocode.com/> ），帮助供应商和终端用户利用新的工具和技术来减少他们的低效率操作…
---
via: <https://www.oreilly.com/learning/network-automation-with-ansible>
作者：[Jason Edelman](https://www.oreilly.com/people/ee4fd-jason-edelman) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
怎样实现由专有环境向开源环境的职业转变
|
Petra Sargent
|
https://opensource.com/article/18/7/career-move
|
学习一点转变到新的技术文化的小技巧。
|
/data/attachment/album/201808/31/001506bv9kzz9vjx63o633.jpeg.thumb.jpg
|
/data/attachment/album/201808/31/001506bv9kzz9vjx63o633.jpeg
| true | false | true |
lujun9972
|
Valoniakim
|
wxy
| false |
[
"职业"
] |
观点
|
{
"viewnum": 3766,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习一点转变到新的技术文化的小技巧。
| 2018-08-31T00:11:00 | 2018-08-31T00:11:00 | 9,965 |
/article-9965-1.html
|
>
> 学习一点转变到新的技术文化的小技巧。
>
>
>
作为一名软件工程师，我的职业生涯是从北电开始的，在这里我开发出了电信级的电话交换机所用的专有软件。 即使我已经在大学中学习了 Pascal 语言，公司还是给我进行了以 C 语言为基础是专有编程语言培养。在公司中我使用的也是专有操作系统和专有版本控制软件。
我很享受专有环境下的工作，并有幸接触了很多有趣的项目，这样过了很多年，直到一场招聘会，我遇到了事业转折点。那时我受邀在当地一所中学的 STEM 行业座谈会进行演讲，给学生们讲述了作为一名软件工程师的主要工作内容和责任，一名学生问我：“这些事是你一直梦想要做的吗？你热爱你现在的工作吗？”
每次领导问我这个问题时，保险起见，我都会回答他，“我当然热爱工作了！”但从来没有一名还在读六年级的单纯的 STEM 小爱好者问过我这个问题。我的回答还是一样，“我当然喜欢！”
我确实很热爱我当时的事业，但那名学生的话让我忍不住思考，我开始重新审视我的事业，重新审视专有环境。在我的领域里我如鱼得水，但这也有局限性：我只能用代码来定义我的领域。我忍不住反思，这些年我在专有环境中学到了不同的技术了吗？在同行中我的技能组还算得上先进吗？我有没有混日子？我真的想继续为这项事业奋斗吗？
我想了很多，忍不住问自己：当年的激情和创意还在吗？
时间不会停止，但我的生活发生了改变。我离开了北电 ，打算休息一段时间来陪陪我的家人。
在我准备返回工作岗位时，那个小朋友的话又在我的脑海中响起，这真的是我想要的工作吗？我投了很多份简历，有一个岗位是我最中意的，但那家公司的回复是，他们想要的是拥有五年及以上的 Java 和 Python 工作经验的人。在过去十五年里我以之为生的知识和技术看起来已经过时了。
### 机遇与挑战
我的第一项挑战是学会在新的环境下应用我先前在封闭环境学到的技能。IT 行业由专有环境转向开源后发生了天翻地覆的变化。我打算先自学眼下最需要的 Python 。接触 Python 后我意识到，我需要一个项目来证明自己的能力，让自己更具有竞争力。
我的第二个挑战是怎么获得 Python 相关的项目经验。我丈夫和之前的同事都向我推荐了开源软件，通过谷歌搜索我发现网上有许许多多的开源项目，它们分别来源于一个人的小团队、50 人左右的团队，还有跨国的百人大团队。
在 Github 上我用相关专业术语搜索出了许多适合我的项目。综合我的兴趣和网络相关的工作经验，我打算把第一个项目贡献给 OpenStack。 我还注意到了 [Outreachy](https://www.outreachy.org/) 项目，它为不具备相关技术基础的人员提供三个月的实习期。
### 经验与教训
我学到的第一件事是我发现可以通过许多方式进行贡献。不论是文件编制、用户设计，还是测试用例，都是贡献的形式。我在探索中丰富了我的技能组，根本用不着 5 年的时间，只需要在开源平台上接受委托，之后做出成果。
在我为 OpenStack 做出的第一个贡献被合并、发表后，我正式成为了 Outreachy 项目的一员。 Outreachy 项目最好的一点是，项目分配给我的导师能够引领我在开源世界中找到方向。
下面还有三个宝贵的提示：
**持之以恒** 你需要找到最适合你核心技能组的项目，当然，最好有行为准则和新人入门指南，这样的项目比较适合初学者加入。找到了合适的项目你可以持之以恒地在社区中进行贡献。
**不厌其烦** 适应开源环境需要一段时间。融入开源社区需要时间。进行深思熟虑的反馈需要时间。阅读反馈并经行改进也需要时间。在这其中你需要耐心等待。
**参与其中** 在开源社区，从事什么领域或技术的工作不需要特殊批准，你可以自己选择工作的领域，并深入其中。
7 月 16-19 日，俄勒冈州波特兰，第 20 届 [开源大会](https://conferences.oreilly.com/oscon/oscon-or) 上，Petra Sargent 将为您展示：[老狗也能学会新把戏——封闭环境工作者如何适应开源环境](https://conferences.oreilly.com/oscon/oscon-or/public/schedule/speaker/307631)。
---
via: <https://opensource.com/article/18/7/career-move>
作者：[Petra Sargent](https://opensource.com/users/psargent) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Valoniakim](https://github.com/Valoniakim) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Fstransform 转换文件系统
|
Atolstoy
|
https://fedoramagazine.org/transform-file-systems-in-linux/
|
Fstransform 可以几乎以任意组合将 ext2、ext3、ext4、jfs、reiserfs 或 xfs 分区转换成另一类型。更重要的是，它可以直接执行，而无需格式化或复制数据。
|
/data/attachment/album/201808/31/002635apr7rhc1jdd46j9c.jpg.thumb.jpg
|
/data/attachment/album/201808/31/002635apr7rhc1jdd46j9c.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"转换",
"文件系统"
] |
分享
|
{
"viewnum": 9722,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Fstransform 可以几乎以任意组合将 ext2、ext3、ext4、jfs、reiserfs 或 xfs 分区转换成另一类型。更重要的是，它可以直接执行，而无需格式化或复制数据。
| 2018-08-31T00:25:00 | 2018-08-31T00:25:00 | 9,966 |
/article-9966-1.html
|
很少有人知道他们可以将文件系统从一种类型转换为另一种类型而不会丢失数据（即非破坏性的）。这可能听起来像魔术，但 [Fstransform](https://github.com/cosmos72/fstransform) 可以几乎以任意组合将 ext2、ext3、ext4、jfs、reiserfs 或 xfs 分区转换成另一类型。更重要的是，它可以直接执行，而无需格式化或复制数据。除此之外，还有一点好处：Fstransform 也可以处理 ntfs、btrfs、fat 和 exfat 分区。
### 在运行之前
Fstransform 存在一些警告和限制，因此强烈建议在尝试转换之前进行备份。此外，使用 Fstransform 时需要注意一些限制：
* 你的 Linux 内核必须支持源文件系统和目标文件系统。听起来很明显，如果你想使用 ext2、ext3、ext4、reiserfs、jfs 和 xfs 分区，这样不会出现风险。Fedora 支持所有分区，所以没问题。
* 将 ext2 升级到 ext3 或 ext4 不需要 Fstransform。请使用 Tune2fs。
* 源文件系统的设备必须至少有 5％ 的可用空间。
* 你需要在开始之前卸载源文件系统。
* 源文件系统存储的数据越多，转换的时间就越长。实际速度取决于你的设备，但预计它大约为每分钟 1GB。大量的硬链接也会降低转换速度。
* 虽然 Fstransform 被证明是稳定的，但请备份源文件系统上的数据。
### 安装说明
Fstransform 已经是 Fedora 的一部分。使用以下命令安装：
```
sudo dnf install fstransform
```
### 转换
`fstransform` 命令的语法非常简单：`fstransform <源设备> <目标文件系统>`。请记住，它需要 root 权限才能运行，所以不要忘记在开头添加 `sudo`。这是一个例子：
```
sudo fstransform /dev/sdb1 ext4
```
请注意，无法转换根文件系统，这是一种安全措施。请改用测试分区或实验性 USB 盘。与此同时，Fstransform 会在控制台中有许多辅助输出。最有用的部分是预计完成时间，让你随时了解该过程需要多长时间。同样，在几乎空的驱动器上的几个小文件将使 Fstransform 在一分钟左右完成其工作，而更多真实世界的任务可能需要数小时的等待时间。
### 更多支持的文件系统
如上所述，可以尝试在 ntfs、btrfs、fat 和 exfat 分区使用 Fstransform。这些类型是早期实验性的，没有人能保证完美转换。尽管如此，还是有许多成功案例，你可以通过在测试分区上使用示例数据集测试 Fstransform 来添加自己的成功案例。可以使用 `--force-untested-file-systems` 参数启用这些额外的文件系统：
```
sudo fstransform /dev/sdb1 ntfs --force-untested-file-systems
```
有时，该过程可能会因错误而中断。请放心再次执行命令 —— 它可能最终会在两、三次尝试后完成转换。
---
via: <https://fedoramagazine.org/transform-file-systems-in-linux/>
作者：[atolstoy](https://fedoramagazine.org/author/atolstoy/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
为什么我仍然喜欢用 Alpine 在 Linux 终端中发送电子邮件
|
Heiko Ossowski
|
https://opensource.com/article/18/8/love-alpine
|
这个免费的邮件客户端使用直观、易于定制，并且可以在许多操作系统上使用。
|
/data/attachment/album/201808/31/201329h2gqcud5q2e0qd1q.jpg.thumb.jpg
|
/data/attachment/album/201808/31/201329h2gqcud5q2e0qd1q.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"邮件",
"Alpine"
] |
观点
|
{
"viewnum": 10009,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这个免费的邮件客户端使用直观、易于定制，并且可以在许多操作系统上使用。
| 2018-08-31T20:13:00 | 2018-08-31T20:13:00 | 9,967 |
/article-9967-1.html
|
>
> 这个免费的邮件客户端使用直观、易于定制，并且可以在许多操作系统上使用。
>
>
>
也许你有这个经历：你试了一个程序，并且很喜欢它。多年后，有新的程序开发出来，它可以做同样的事情或者更多，甚至更好。你试了下它们，它们也很棒 —— 但你会继续使用第一个程序。
这是我与 [Alpine Mail](https://en.wikipedia.org/wiki/Alpine_(email_client)) 关系的故事。所以我决定写一篇赞美我最喜欢的邮件程序的文章。
*Alpine 邮件客户端的主菜单屏幕*
在 90 年代中期，我发现了 [GNU/Linux](https://www.gnu.org/gnu/linux-and-gnu.en.html) 操作系统。因为我之前从未见过类 Unix 的系统，所以我阅读了大量的文档和书籍，并尝试了很多程序来熟悉这个迷人的系统。
没多久，[Pine](https://en.wikipedia.org/wiki/Pine_(email_client)) 成了我最喜欢的邮件客户端，其后是其继任者 Alpine。我发现它直观且易于使用 —— 你始终可以在底部看到可能的命令或选项，因此引导很容易快速学习，并且 Alpine 提供了很好的帮助。
入门很容易。
大多数发行版包含 Alpine。它可以通过包管理器安装。
只需按下 `S`（或移动高亮栏到“设置”那一行）你就会看到可以配置的项目。在底部，你可以使用快捷键来执行你可以立即执行的命令。对于其他命令，按下 `O`（“其他命令”）。
按下 `S` 进入配置对话框。当你向下滚动列表时，很明显你可以设置 Apline 如你所希望的那样运行。如果你只有一个邮件帐户，只需移动到你想要更改的行，按下 `C`（“更改值”），然后输入值：
*Alpine 设置配置屏幕*
请注意如何输入 SNMP 和 IMAP 服务器，因为这与那些有辅助助手和预填字段的邮件客户端不同。如果你像这样输入“服务器/SSL/用户”：
```
imap.myprovider.com:993/ssl/user=max@example.com
```
Alpine 会询问你是否使用“收件箱”（选择“是”）并在“服务器”两边加上大括号。完成后，按下 `E`（“退出设置”）并按下 `Y`（“是”）提交更改。回到主菜单，然后你可以移动到文件夹列表和收件箱以查看是否有邮件（系统将提示你输入密码）。你现在可以使用 `>` 和 `<` 进行移动。
*在 Apline 中浏览消息索引*
要撰写邮件，只需移动到相应的菜单并编写即可。请注意，底部的选项会根据你所在的行而变化。`^T`（`Ctrl + T`）可代表 To Addressbook（“地址簿”）或 To Files（“文件”）。要附加文件，只需移动到 Attchmt:（“附件”）然后按 `Ctrl + T` 转到文件浏览器，或按 `Ctrl + J` 输入路径。
用 `^X` 发送邮件。
*在 Alpine 中撰写电子邮件*
### 为何选择 Alpine？
当然，每个用户的个人偏好和需求都是不同的。如果你需要一个更像 “office” 的解决方案，像 Evolution 或 Thunderbird 这样的应用可能是更好的选择。
但对我来说，Alpine（和 Pine）是软件界的活化石。你可以以舒适的方式管理邮件 —— 不多也不少。它适用于许多操作系统（甚至 [Termux for Android](https://termux.com/)）。并且因为配置存储在纯文本文件（`.pinerc`）中，所以你只需将其复制到设备即可。
---
via: <https://opensource.com/article/18/8/love-alpine>
作者：[Heiko Ossowski](https://opensource.com/users/hossow) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
适用于 Fedora 28 的 3 款酷炫生产力应用
|
Paul W. Frields
|
https://fedoramagazine.org/3-cool-productivity-apps/
|
假设你使用 Fedora 系统。你能找到帮助你完成工作的程序吗？当然！请继续阅读了解这些帮助你专注目标的程序。
|
/data/attachment/album/201808/31/222709u2ua9vpsz2fpnkom.jpg.thumb.jpg
|
/data/attachment/album/201808/31/222709u2ua9vpsz2fpnkom.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"生产力"
] |
分享
|
{
"viewnum": 4812,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
假设你使用 Fedora 系统。你能找到帮助你完成工作的程序吗？当然！请继续阅读了解这些帮助你专注目标的程序。
| 2018-08-31T22:27:07 | 2018-08-31T22:27:07 | 9,968 |
/article-9968-1.html
|
生产力应用在移动设备上特别受欢迎。但是当你坐下来做工作时，你经常在笔记本电脑或台式电脑上工作。假设你使用 Fedora 系统。你能找到帮助你完成工作的程序吗？当然！请继续阅读了解这些帮助你专注目标的程序。
所有这些程序都可以在 Fedora 系统上免费使用。当然，它们也维护了你的自由。 （许多还允许你使用你可能已经拥有帐户的现有服务。）
### FocusWriter
FocusWriter 只是一个全屏文字处理器。该程序可以提高你的工作效率，因为它覆盖了屏幕其他地方。当你使用 FocusWriter 时，除了你和文本，别无它物。有了这个程序，你可以专注于你的想法，减少分心。
[](https://fedoramagazine.org/wp-content/uploads/2018/07/Screenshot-from-2018-07-15-18-10-18.png)
FocusWriter 允许你调整字体、颜色和主题以最适合你的喜好。它还会记住你上一个文档和位置。此功能可让你快速重新专注于书写。
要安装 FocusWriter，请使用 Fedora Workstation 中的软件中心。或者在终端中[使用 sudo](https://fedoramagazine.org/howto-use-sudo/) 运行此命令：
```
sudo dnf install focuswriter
```
### GNOME ToDo
你可以猜到这个独特的程序是为 GNOME 桌面环境设计的。因此，它非常适合你的 Fedora Workstation。ToDo 有一个简单的目的：它可以让你列出你需要完成的事情。
使用 ToDo，你可以为所有任务确定优先级并安排截止日期。你还可以根据需要构建任意数量的任务列表。ToDo 有大量提供了有用功能的扩展，以提高你的工作效率。这些包括 GNOME Shell 通知，以及带有 todo.txt 的列表管理。如果你有 Todoist 或者 Google 帐户，ToDo 甚至可以与它们交互。它可以同步任务，因此你可以跨设备共享。
要安装它，在软件中心搜索 ToDo，或在命令行运行：
```
sudo dnf install gnome-todo
```
### Zanshin
如果你是使用 KDE 的生产力粉丝，你可能会喜欢 [Zanshin](https://zanshin.kde.org/)。该行事历可帮助你规划跨多个项目的操作。它有完整的功能界面，可让你浏览各种任务，以了解下一步要做的最重要的事情。
[](https://fedoramagazine.org/wp-content/uploads/2018/07/Screenshot_20180715_192216.png)
Zanshin 非常适合键盘操作，因此你可在钻研时提高效率。它还集成了众多 KDE 程序以及 Plasma 桌面。你可以将其与 KMail、KOrganizer 和 KRunner 一起使用。
要安装它，请运行以下命令：
```
sudo dnf install zanshin
```
---
via: <https://fedoramagazine.org/3-cool-productivity-apps/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
一个转换花引号的 gawk 脚本
|
Jim Hall
|
https://opensource.com/article/18/8/gawk-script-convert-smart-quotes
|
得到我的 awk 秘籍。
|
/data/attachment/album/201808/31/223600zlqjltbr1aljlqpa.png.thumb.jpg
|
/data/attachment/album/201808/31/223600zlqjltbr1aljlqpa.png
| true | false | true |
lujun9972
|
lujun9972
|
wxy
| false |
[
"awk"
] |
软件开发
|
{
"viewnum": 4001,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
得到我的 awk 秘籍。
| 2018-08-31T22:35:00 | 2018-08-31T22:35:00 | 9,969 |
/article-9969-1.html
|
>
> 得到我的 awk 秘籍。
>
>
>
我管理着一个个人网站，用手工编辑网站上的网页。由于网站上的页面并不多，这种方法对我很适合，可以让我对网站代码的细节一清二楚。
最近我升级了网站的设计样式，我决定把所有的普通引号都转换成“花引号”，即在打印材料中使用的那种引号：用 “” 来代替 ""。
手工修改所有的引号太耗时了，因此我决定将这个转换所有 HTML 文件中引号的过程自动化。不过通过程序或脚本来实现该功能需要费点劲。这个脚本需要知道何时将普通引号转换成花引号，并决定使用哪种引号（LCTT 译注：左引号还是右引号，单引号还是双引号）。
有多种方法可以转换引号。Greg Pittman 写过一个 [Python 脚本](https://opensource.com/article/17/3/python-scribus-smart-quotes) 来修正文本中的花引号。而我自己使用 GNU [awk](https://opensource.com/downloads/cheat-sheet-awk-features) (gawk) 来实现。
>
> 下载我的 awk 秘籍。[免费下载](https://opensource.com/downloads/cheat-sheet-awk-features)。
>
>
>
开始之前，我写了一个简单的 gawk 函数来评估单个字符。若该字符是一个引号，这该函数判断是输出普通引号还是花引号。函数查看前一个字符；若前一个字符是空格，则函数输出左花引号。否则函数输出右花引号。脚本对单引号的处理方式也一样。
```
function smartquote (char, prevchar) {
# print smart quotes depending on the previous character
# otherwise just print the character as-is
if (prevchar ~ /\s/) {
# prev char is a space
if (char == "'") {
printf("‘");
}
else if (char == "\"") {
printf("“");
}
else {
printf("%c", char);
}
}
else {
# prev char is not a space
if (char == "'") {
printf("’");
}
else if (char == "\"") {
printf("”");
}
else {
printf("%c", char);
}
}
}
```
这个 gawk 脚本的主体部分通过该函数处理 HTML 输入文件的一个个字符。该脚本在 HTML 标签内部逐字原样输出所有内容（比如，`<html lang="en">`）。在 HTML 标签外，脚本使用 `smartquote()` 函数来输出文本。`smartquote()` 函数来评估是输出普通引号还是花引号。
```
function smartquote (char, prevchar) {
...
}
BEGIN {htmltag = 0}
{
# for each line, scan one letter at a time:
linelen = length($0);
prev = "\n";
for (i = 1; i <= linelen; i++) {
char = substr($0, i, 1);
if (char == "<") {
htmltag = 1;
}
if (htmltag == 1) {
printf("%c", char);
}
else {
smartquote(char, prev);
prev = char;
}
if (char == ">") {
htmltag = 0;
}
}
# add trailing newline at end of each line
printf ("\n");
}
```
下面是一个例子：
```
gawk -f quotes.awk test.html > test2.html
```
其输入为：
```
<!DOCTYPE html>
<html lang="en">
<head>
<title>Test page</title>
<link rel="stylesheet" type="text/css" href="/test.css" />
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width" />
</head>
<body>
<h1><a href="/"><img src="logo.png" alt="Website logo" /></a></h1>
<p>"Hi there!"</p>
<p>It's and its.</p>
</body>
</html>
```
其输出为：
```
<!DOCTYPE html>
<html lang="en">
<head>
<title>Test page</title>
<link rel="stylesheet" type="text/css" href="/test.css" />
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width" />
</head>
<body>
<h1><a href="/"><img src="logo.png" alt="Website logo" /></a></h1>
<p>“Hi there!”</p>
<p>It’s and its.</p>
</body>
</html>
```
---
via: <https://opensource.com/article/18/8/gawk-script-convert-smart-quotes>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
极客漫画：函数式编程的世界
|
Daniel Stori
|
http://turnoff.us/geek/functional-world/
|
作者巧妙地指出了函数式编程不可变的特点。当你需要改变一个对象的属性的时候……嗯，销毁了再创建一个就是了。
|
/data/attachment/album/201808/31/224849a7ek4iuqw9dm0urq.png.thumb.jpg
|
/data/attachment/album/201808/31/224849a7ek4iuqw9dm0urq.png.large.jpg
| false | false | true |
ItsLucas
|
Bestony
| false |
[
"函数式"
] |
极客漫画
|
{
"viewnum": 14322,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
作者巧妙地指出了函数式编程不可变的特点。当你需要改变一个对象的属性的时候……嗯，销毁了再创建一个就是了。
| 2018-08-31T22:49:45 | 2018-08-31T22:49:45 | 9,970 |
/article-9970-1.html
|
作者巧妙地指出了函数式编程<ruby> 不可变 <rp> （ </rp> <rt> immultable </rt> <rp> ） </rp></ruby>的特点。当你需要改变一个对象的属性的时候……嗯，销毁了再创建一个就是了。
这里的老板想来份变量（改变全局变量的值），而所谓<ruby> 副作用 <rp> （ </rp> <rt> side effect </rt> <rp> ） </rp></ruby>，指的是在这种编程范式下，函数内部与外部互动可能会产生运算以外的其他结果，或导致程序出现不可预料的行为。
或许，事件驱动的编程范式会好一点……？
---
via: <http://turnoff.us/geek/functional-world/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&点评：[ItsLucas](https://github.com/ItsLucas) 校对&合成 ：[Bestony](https://github.com/bestony)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
在开源“集市”工作时如何建立一个职业网络
|
Heidi Hess Von Ludewig
|
https://opensource.com/open-organization/18/6/building-professional-social-networks-openly
|
在组织内建立联系遇到问题了吗？你或许是采用了错误的策略。
|
/data/attachment/album/201809/01/212141g3km3m4jw54s4wm5.png.thumb.jpg
|
/data/attachment/album/201809/01/212141g3km3m4jw54s4wm5.png
| true | false | true |
lujun9972
|
ZenMoore
|
wxy
| false |
[
"职业"
] |
观点
|
{
"viewnum": 3517,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在组织内建立联系遇到问题了吗？你或许是采用了错误的策略。
| 2018-09-01T21:21:15 | 2018-09-01T21:21:15 | 9,971 |
/article-9971-1.html
|
>
> 在组织内建立联系遇到问题了吗？你或许是采用了错误的策略。
>
>
>
职业社交网络 —— 在同事或专业人员之间建立人际联系 —— 可以采用多种形式、在产业内跨组织进行。建立职业网络需要花费时间和精力，并且当某位成员加入或离开一个组织时，此人的网络通常需要被在一个新的工作环境中重建。
职业社交网络在不同组织中起相似作用 —— 信息共享、导师制、机会、工作利益和其他作用 —— 然而传统组织与开放组织在组织内构建特定联系的*方法*和*原因*可能不尽相同。这些差异有其影响：同事联系方式、如何建立信任、组织内多元化的程度和种类以及建立合作的能力，所有这些因素都是相互关联的，而且它们参与并塑造了人们所建立的社交网络。
一个开放的组织对包容性的强调可以使社交网络在解决商业问题上比传统等级制组织更加高效。这种观念在开源的思考中有很久的历史。例如，在<ruby> <a href="http://www.catb.org/%7Eesr/writings/cathedral-bazaar/cathedral-bazaar/ar01s04.html"> 《教堂与集市》 </a> <rt> The Cathedral and the Bazaar </rt></ruby>中，埃里克·雷蒙德写道：“许多年前社会学家发现，相比一个随机选择的观察者的观点，许多同等专业的（或是同等无知的）观察家的普遍观点是可靠得多的预言。”所以让我们了解社交网络的结构和目的如何影响各类组织的价值观。
### 传统组织中的社交网络
当我在传统组织工作并要描述我为工作做了什么时，人们问我的第一件事就是我与其他人（通常是总监级的领导）的关系。“你在希拉手下吗？”他们会这么问。“你为马尔科姆工作吗？”这意味着以一种上下级的视角看待传统组织的作用；当试图安排工作或雇员时，人们想要从上下级的角度理解网络结构。
换言之，在传统组织中社交网络依赖于等级制结构，因此他们彼此跟随。事实上，甚至弄清一个雇员在关系网中处于怎样的位置也算得上是一种“上下级组织”式的担忧。
然而并非所有潜在等级制都是如此。它还视相关人员而定。对于上下级网络的关注会决定雇员在网络中的“价值”，因为网络本身是一个持续的权力关系的系统，它会根据人不同水平的价值给予他们不同的定位。它淡化了个人的能力和技能的重要性。因此，一个人在传统组织的联系促使其能力具有前瞻性，为人所知，有影响力并在其事业中起到支持作用。
相比传统等级制组织，一个开放的组织对包容性的强调能使网络解决商业问题更加高效。
传统组织的正式结构以特定方式决定着雇员的社交网络 —— 有些可能是优点，有些可能是缺点，这取决于具体环境——例如：
* 要更快速地了解“谁是谁”并看到人们如何关联是较为便捷的（通常这在特定层级内建立信任网络）。
* 通常，这种对关系的进一步的理解意味着会有更少的过剩工作（在一个特定网络中项目有清晰的相应的归属者）和过多交流（人们知道谁对交流什么负责）。
* 相关人员会感到在一个权力结构中感到束手无策，或好像他们不能“闯入”权力结构中，这些结构有时（或更多时候）因为裁员并不起作用。
* 完成大量的工作和努力是困难的，并且合作会很艰难。
* 权力转让缓慢；一个人的参与能力更多地决定于等级结构所创造的网络的结盟而非其他因素（比如个人能力），减少了被看做社区和成员利益的东西。
* 竞争似乎更加清晰；理解“谁在竞争什么”通常发生在一个公认的、被限定了的等级结构中（权力网络中职位的缺乏增进了竞争因此竞争会更激烈）。
* 当更严格的网络决定了灵活性的限度时，适应能力会受损。网络的“夙愿”和合作的限度也会以同样的方式受影响。
* 在严格的网络中，方向明确，并且领导人通常靠过度指导来进行管理，在这里，破坏更容易发生。
* 当社交网络不那么灵活时，风险下降；人们知道什么需要发生，怎样发生，何时发生（但是考虑到在一个组织中工作的广度，这不见得总是“坏事”；一些工作的职能需要较小的风险，例如：人力资源管理 HR）,企业并购和法律工作等。
* 在网络中的信任是更大的，尤其当受雇者是正式网络的一部分的时候（当某人不是网络的一份子时，被排斥的人可能特别难管理或改正）。
### 开放组织中的社交网络
尽管开放组织必定会有等级结构，但他们并不根据那个网络运作。他们的职业网络结构更加灵活（或者说是“随时随地”）。
在一个开放的组织中，当我描述我做了什么工作时，几乎没人问我“我为谁而干？”一个开放的组织更多的以伙伴为中心，而不是以领导为中心。开放的价值观比如包容和特定的治理系统比如强人治理有助于此；那并不是你了解谁而是你了解什么，你怎样使用（比如：“自底而上的设计”）。在一个开放的组织当中，我并不感觉我在为展示自己的价值而奋斗；我的想法有内在的价值。有时我必须示范说明为何使用我的观点比使用别人的更加有用——但是那意味着我正在同事的社区里面诊疗我自己（包括领导层），而不是单独被自上而下的领导层诊疗。
如此说来，开放的组织并不基于网络评估员工，而是基于他们对作为个人的同事的了解。这个人有想法吗？她会努力通过利用开放组织的价值实现那些想法吗（领导它们）(也就是说，在开放组织中分享那些观点并且实践以将他人囊括并透明公开的工作等等)？
开放组织也会以特定的方式构造社交网络（这种方式同样可能会视个人的目的性和渴望程度而很有益或很有害），这包括：
* 人们会对他们的网络、声望、技能和事业更加负责。
* 竞争(为了资源、权力、晋升等)会因这些组织天性更具合作性而变得更少。最好的结果是协商，而不是单赢，并且竞争会磨练创意，而不会在人与人之间筑篱设笆。
* 权力是更加流动和有活力的，在人与人之间流动（但这同时也意味着可能有对可说明性或者责任的误解，而且活动可能会因为没有明晰的[主人翁意识](https://opensource.com/open-organization/18/4/rethinking-ownership-across-organization)而不被完成）。
* 信任是“一次一同事”地被建立起来的而不会借助社交网络，在网络中，人是被定位着的。
* 网络在多样的运转和事件中会自配置，一有机会便会反应性地自启（这帮助了更新但却会造成混乱，因为谁在决策、谁在“受控”是不那么明确的）。
* 执行速度在混乱的环境中会下降，因为所做之事、做事方式和处事时间需要在制定目标和涵养好整以暇的员工方面上的领导力。
* 灵活的社交网络同样会增加变革和风险；创意会流通得更快而且更神奇，并且执行会更加自信。
* 信任建立在同事合作之上（它本该如此！），而不是在对架构的尊重之上。
### 让它有效
如果你正在考虑从一种组织架构转变为另一种，当你在构建并维持你的职业社交网络时思考一下如下所述内容。
#### 来自传统组织的小建议
* 对决策的架构和管控不是坏事；运作中的框架需要明晰透明，而且决策者需要考虑他们的决定。
* 在执行上突出需要经理提供关注，还需要有在滤出任何让人分心或混乱的事务的同时仍能提供足够的来龙去脉的能力。
* 已经确立的网络帮助了一大批人同步工作并且能管控风险。
#### 来自开放组织的小建议
* 能力强的领导人是那些可以根据多样的风格和对同事、团队的不同偏好提供不同层次的透明度和指导，同时又不会构建出不灵活的网络的人。
* 伟大的想法比已建立的组织会赢得更多。
* 人们对他们的名声会更加负责任。
* 创意和信息的流转是变革的关键。松散组织中的关系网络可以使这两种元素生发的频度更高、幅度更广。
---
via: <https://opensource.com/open-organization/18/6/building-professional-social-networks-openly>
作者：[Heidi Hess von Ludewig](https://opensource.com/users/heidi-hess-von-ludewig) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ZenMoore](https://github.com/ZenMoore) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux DNS 查询剖析（第三部分）
|
Zwischenzugs
|
https://zwischenzugs.com/2018/07/06/anatomy-of-a-linux-dns-lookup-part-iii/
|
在第三部分中，我将介绍 NetworkManager 和 dnsmasq，简要说明它们如何影响 DNS 查询。
|
/data/attachment/album/201809/01/213042p0w0wwdwhmh0w6wx.jpeg.thumb.jpg
|
/data/attachment/album/201809/01/213042p0w0wwdwhmh0w6wx.jpeg
| true | false | true |
oska874
|
pinewall
|
wxy
| false |
[
"DNS"
] |
技术
|
{
"viewnum": 9244,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9949,
"displayorder": 0
},
{
"raid": 10056,
"displayorder": 0
}
] |
在第三部分中，我将介绍 NetworkManager 和 dnsmasq，简要说明它们如何影响 DNS 查询。
| 2018-09-01T21:30:59 | 2018-09-01T21:30:59 | 9,972 |
/article-9972-1.html
|
在 [Linux DNS 查询剖析（第一部分）](/article-9943-1.html)中，我们介绍了：
* `nsswitch`
* `/etc/hosts`
* `/etc/resolv.conf`
* `ping` 与 `host` 查询方式的对比
而在 [Linux DNS 查询剖析（第二部分）](/article-9949-1.html)，我们介绍了：
* `systemd` 和对应的 `networking` 服务
* `ifup` 和 `ifdown`
* `dhclient`
* `resolvconf`
剖析进展如下：
*（大致）准确的关系图*
很可惜，故事还没有结束，还有不少东西也会影响 DNS 查询。在第三部分中，我将介绍 `NetworkManager` 和 `dnsmasq`，简要说明它们如何影响 DNS 查询。
### 1) NetworkManager
在第二部分已经提到，我们现在介绍的内容已经偏离 POSIX 标准，涉及的 DNS 解析管理部分在各个发行版上形式并不统一。
在我使用的发行版 （Ubuntu）中，有一个名为 [NetworkManager](https://en.wikipedia.org/wiki/NetworkManager) 的<ruby> 可用 <rt> available </rt></ruby>服务，它通常作为一些其它软件包的依赖被安装。它实际上是 RedHat 在 2004 年开发的一个服务，用于帮助你管理网络接口。
它与 DNS 查询有什么关系呢？让我们安装这个服务并找出答案：
```
$ apt-get install -y network-manager
```
对于 Ubuntu，在软件包安装后，你可以发现一个新的配置文件：
```
$ cat /etc/NetworkManager/NetworkManager.conf
[main]
plugins=ifupdown,keyfile,ofono
dns=dnsmasq
[ifupdown]
managed=false
```
看到 `dns=dnsmasq` 了吧？这意味着 `NetworkManager` 将使用 `dnsmasq` 管理主机上的 DNS。
### 2) dnsmasq
`dnsmasq` 程序是我们很熟悉的程序：只是 `/etc/resolv.conf` 之上的又一个间接层。
理论上，`dnsmasq` 有多种用途，但主要被用作 DNS 缓存服务器，缓存到其它 DNS 服务器的请求。`dnsmasq` 在本地所有网络接口上监听 53 端口（标准的 DNS 端口）。
那么 `dnsmasq` 运行在哪里呢？`NetworkManager` 的运行情况如下：
```
$ ps -ef | grep NetworkManager
root 15048 1 0 16:39 ? 00:00:00 /usr/sbin/NetworkManager --no-daemon
```
但并没有找到 `dnsmasq` 相关的进程：
```
$ ps -ef | grep dnsmasq
$
```
令人迷惑的是，虽然 `dnsmasq` 被配置用于管理 DNS，但其实并没有安装在系统上！因而，你需要自己安装它。
安装之前，让我们查看一下 `/etc/resolv.conf` 文件的内容：
```
$ cat /etc/resolv.conf
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 10.0.2.2
search home
```
可见，并没有被 `NetworkManager` 修改。
如果安装 `dnsmasq`：
```
$ apt-get install -y dnsmasq
```
然后启动运行 `dnsmasq`：
```
$ ps -ef | grep dnsmasq
dnsmasq 15286 1 0 16:54 ? 00:00:00 /usr/sbin/dnsmasq -x /var/run/dnsmasq/dnsmasq.pid -u dnsmasq -r /var/run/dnsmasq/resolv.conf -7 /etc/dnsmasq.d,.dpkg-dist,.dpkg-old,.dpkg-new --local-service --trust-anchor=.,19036,8,2,49AAC11D7B6F6446702E54A1607371607A1A41855200FD2CE1CDDE32F24E8FB5
```
然后，`/etc/resolv.conf` 文件内容又改变了！
```
root@linuxdns1:~# cat /etc/resolv.conf
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 127.0.0.1
search home
```
运行 `netstat` 命令，可以看出 `dnsmasq` 在所有网络接口上监听 53 端口：
```
$ netstat -nlp4
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN 15286/dnsmasq
tcp 0 0 10.0.2.15:53 0.0.0.0:* LISTEN 15286/dnsmasq
tcp 0 0 172.28.128.11:53 0.0.0.0:* LISTEN 15286/dnsmasq
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 1237/sshd
udp 0 0 127.0.0.1:53 0.0.0.0:* 15286/dnsmasq
udp 0 0 10.0.2.15:53 0.0.0.0:* 15286/dnsmasq
udp 0 0 172.28.128.11:53 0.0.0.0:* 15286/dnsmasq
udp 0 0 0.0.0.0:68 0.0.0.0:* 10758/dhclient
udp 0 0 0.0.0.0:68 0.0.0.0:* 10530/dhclient
udp 0 0 0.0.0.0:68 0.0.0.0:* 10185/dhclient
```
### 3) 分析 dnsmasq
在目前的情况下，所有的 DNS 查询都会使用 `127.0.0.1:53` 这个 DNS 服务器，下一步会发生什么呢？
我再次查看 `/var/run` 目录，可以发现一个线索：`resolvconf` 目录下 `resolv.conf` 文件中的配置也相应变更，变更为 `dnsmasq` 对应的 DNS 服务器：
```
$ cat /var/run/resolvconf/resolv.conf
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 127.0.0.1
search home
```
同时，出现了一个新的 `dnsmasq` 目录，也包含一个 `resolv.conf` 文件：
```
$ cat /run/dnsmasq/resolv.conf
nameserver 10.0.2.2
```
（LCTT 译注：这里依次提到了 `/var/run` 和 `/run`，使用 Ubuntu 16.04 LTS 验证发现，`/var/run` 其实是指向 `/run/` 的软链接）
该文件包含我们从 `DHCP` 获取的 `nameserver`。
虽然可以推导出这个结论，但如何查看具体的调用逻辑呢？
### 4) 调试 dnsmasq
我经常思考 `dnsmasq` （在整个过程中）的功能定位。幸运的是，如果你将 `/etc/dnsmasq.conf` 中的一行做如下调整，你可以获取大量 `dnsmasq` 状态的信息：
```
#log-queries
```
修改为：
```
log-queries
```
然后重启 `dnsmasq`。
接下来，只要运行一个简单的命令：
```
$ ping -c1 bbc.co.uk
```
你就可以在 `/var/log/syslog` 中找到类似的内容（其中 `[...]` 表示行首内容与上一行相同）：
```
Jul 3 19:56:07 ubuntu-xenial dnsmasq[15372]: query[A] bbc.co.uk from 127.0.0.1
[...] forwarded bbc.co.uk to 10.0.2.2
[...] reply bbc.co.uk is 151.101.192.81
[...] reply bbc.co.uk is 151.101.0.81
[...] reply bbc.co.uk is 151.101.64.81
[...] reply bbc.co.uk is 151.101.128.81
[...] query[PTR] 81.192.101.151.in-addr.arpa from 127.0.0.1
[...] forwarded 81.192.101.151.in-addr.arpa to 10.0.2.2
[...] reply 151.101.192.81 is NXDOMAIN
```
可以清晰看出 `dnsmasq` 收到的查询、查询被转发到了哪里以及收到的回复。
如果查询被缓存命中（或者说，本地的查询结果还在<ruby> 存活时间 <rt> time-to-live </rt></ruby> TTL 内，并未过期），日志显示如下：
```
[...] query[A] bbc.co.uk from 127.0.0.1
[...] cached bbc.co.uk is 151.101.64.81
[...] cached bbc.co.uk is 151.101.128.81
[...] cached bbc.co.uk is 151.101.192.81
[...] cached bbc.co.uk is 151.101.0.81
[...] query[PTR] 81.64.101.151.in-addr.arpa from 127.0.0.1
```
如果你想了解缓存中有哪些记录，可以向 `dnsmasq` 进程 id 发送 `USR1` 信号，这样 `dnsmasq` 会将缓存记录导出并写入到相同的日志文件中：
```
$ kill -SIGUSR1 $(cat /run/dnsmasq/dnsmasq.pid)
```
（LCTT 译注：原文中命令执行报错，已变更成最接近且符合作者意图的命令）
导出记录对应如下输出：
```
Jul 3 15:08:08 ubuntu-xenial dnsmasq[15697]: time 1530630488
[...] cache size 150, 0/5 cache insertions re-used unexpired cache entries.
[...] queries forwarded 2, queries answered locally 0
[...] queries for authoritative zones 0
[...] server 10.0.2.2#53: queries sent 2, retried or failed 0
[...] Host Address Flags Expires
[...] linuxdns1 172.28.128.8 4FRI H
[...] ip6-localhost ::1 6FRI H
[...] ip6-allhosts ff02::3 6FRI H
[...] ip6-localnet fe00:: 6FRI H
[...] ip6-mcastprefix ff00:: 6FRI H
[...] ip6-loopback : 6F I H
[...] ip6-allnodes ff02: 6FRI H
[...] bbc.co.uk 151.101.64.81 4F Tue Jul 3 15:11:41 2018
[...] bbc.co.uk 151.101.192.81 4F Tue Jul 3 15:11:41 2018
[...] bbc.co.uk 151.101.0.81 4F Tue Jul 3 15:11:41 2018
[...] bbc.co.uk 151.101.128.81 4F Tue Jul 3 15:11:41 2018
[...] 151.101.64.81 4 R NX Tue Jul 3 15:34:17 2018
[...] localhost 127.0.0.1 4FRI H
[...] <Root> 19036 8 2 SF I
[...] ip6-allrouters ff02::2 6FRI H
```
在上面的输出中，我猜测（并不确认，`?` 代表我比较无根据的猜测）如下：
* `4` 代表 IPv4
* `6` 代表 IPv6
* `H` 代表从 `/etc/hosts` 中读取 IP 地址
* `I` ？ “永生”的 DNS 记录 ？ (例如，没有设置存活时间数值 ？)
* `F` ？
* `R` ？
* `S` ？
* `N` ？
* `X`
（LCTT 译注：查看 `dnsmasq` 的源代码 [`cache.c`](https://github.com/imp/dnsmasq/blob/master/src/cache.c) 可知，`4` 代表 `IPV4`，`6` 代表 `IPV6`，`C` 代表 `CNAME`，`S` 代表 `DNSSEC`，`F` 代表 `FORWARD`，`R` 代表 `REVERSE`，`I` 代表 `IMMORTAL`，`N` 代表 `NEG`，`X` 代表 `NXDOMAIN`，`H` 代表 `HOSTS`。更具体的含义需要查看代码或相关文档）
#### dnsmasq 的替代品
`NetworkManager` 配置中的 `dns` 字段并不是只能使用 `dnsmasq`，可选项包括 `none`，`default`，`unbound` 和 `dnssec-triggered` 等。使用 `none` 时，`NetworkManager` 不会改动 `/etc/resolv.conf`；使用 `default` 时，`NetworkManager` 会根据当前的<ruby> 活跃连接 <rt> active connections </rt></ruby>更新 `resolv.conf`；使用 `unbound` 时，`NetworkManager` 会与 `unbound` 服务通信；`dnssec-triggered` 与 DNS 安全相关，不在本文讨论范围。
### 第三部分总结
第三部分到此结束，其中我们介绍了 `NetworkManager` 服务及其 `dns=dnsmasq` 的配置。
下面简要罗列一下我们已经介绍过的全部内容：
* `nsswitch`
* `/etc/hosts`
* `/etc/resolv.conf`
* `/run/resolvconf/resolv.conf`
* `systemd` 及对应的 `networking` 服务
* `ifup` 和 `ifdown`
* `dhclient`
* `resolvconf`
* `NetworkManager`
* `dnsmasq`
---
via: <https://zwischenzugs.com/2018/07/06/anatomy-of-a-linux-dns-lookup-part-iii/>
作者：[ZWISCHENZUGS](https://zwischenzugs.com/) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
全面教程：在 RxJS 中创建流
|
Oliver Flaggl
|
https://blog.angularindepth.com/the-extensive-guide-to-creating-streams-in-rxjs-aaa02baaff9a
|
有些时候，混用响应式和非响应式代码似乎很有用。然后大家就开始热衷流的创造。不论是在编写异步代码或者是数据处理时，流都是一个不错的方案。
|
/data/attachment/album/201809/01/225906f2vnvoglzjzmn37l.jpg.thumb.jpg
|
/data/attachment/album/201809/01/225906f2vnvoglzjzmn37l.jpg
| true | false | true |
BriFuture
|
wxy
| false |
[
"stream",
"RxJS"
] |
软件开发
|
{
"viewnum": 5127,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有些时候，混用响应式和非响应式代码似乎很有用。然后大家就开始热衷流的创造。不论是在编写异步代码或者是数据处理时，流都是一个不错的方案。
| 2018-09-01T22:59:02 | 2018-09-01T22:59:02 | 9,973 |
/article-9973-1.html
|
对大多数开发者来说，与 RxJS 的初次接触是通过库的形式，就像 Angular。一些函数会返回<ruby> 流 <rt> stream </rt></ruby>，要使用它们就得把注意力放在操作符上。
有些时候，混用响应式和非响应式代码似乎很有用。然后大家就开始热衷流的创造。不论是在编写异步代码或者是数据处理时，流都是一个不错的方案。
RxJS 提供很多方式来创建流。不管你遇到的是什么情况，都会有一个完美的创建流的方式。你可能根本用不上它们，但了解它们可以节省你的时间，让你少码一些代码。
我把所有可能的方法，按它们的主要目的，放在四个分类当中：
* 流式化现有数据
* 生成数据
* 使用现有 API 进行交互
* 选择现有的流，并结合起来
注意：示例用的是 RxJS 6，可能会以前的版本有所不同。已知的区别是你导入函数的方式不同了。
RxJS 6
```
import {of, from} from 'rxjs';
of(...);
from(...);
```
RxJS < 6
```
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/observable/of';
import 'rxjs/add/observable/from';
Observable.of(...);
Observable.from(...);
//或
import { of } from 'rxjs/observable/of';
import { from } from 'rxjs/observable/from';
of(...);
from(...);
```
流的图示中的标记：
* `|` 表示流结束了
* `X` 表示流出现错误并被终结
* `...` 表示流的走向不定
### 流式化已有数据
你有一些数据，想把它们放到流中。有三种方式，并且都允许你把调度器当作最后一个参数传入（你如果想深入了解调度器，可以看看我的 [上一篇文章](https://itnext.io/concurrency-and-asynchronous-behavior-with-rxjs-11b0c4b22597)）。这些生成的流都是静态的。
#### of
如果只有一个或者一些不同的元素，使用 `of`：
```
of(1,2,3)
.subscribe();
```
```
// 结果
// 1 2 3 |
```
#### from
如果有一个数组或者 *可迭代的对象* ，而且你想要其中的所有元素发送到流中，使用 `from`。你也可以用它来把一个 promise 对象变成可观测的。
```
const foo = [1,2,3];
from(foo)
.subscribe();
```
```
// 结果
// 1 2 3 |
```
#### pairs
流式化一个对象的键/值对。用这个对象表示字典时特别有用。
```
const foo = { a: 1, b: 2};
pairs(foo)
.subscribe();
```
```
// 结果
// [a,1] [b,2] |
```
#### 那么其他的数据结构呢？
也许你的数据存储在自定义的结构中，而它又没有实现 *可迭代的对象* 接口，又或者说你的结构是递归的、树状的。也许下面某种选择适合这些情况：
1. 先将数据提取到数组里
2. 使用下一节将会讲到的 `generate` 函数，遍历所有数据
3. 创建一个自定义流（见下一节）
4. 创建一个迭代器
稍后会讲到选项 2 和 3 ，因此这里的重点是创建一个迭代器。我们可以对一个 *可迭代的对象* 调用 `from` 创建一个流。 *可迭代的对象* 是一个对象，可以产生一个迭代器（如果你对细节感兴趣，参考 [这篇 mdn 文章](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols)）。
创建一个迭代器的简单方式是 <ruby> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*"> 生成函数 </a> <rt> generator function </rt></ruby>。当你调用一个生成函数时，它返回一个对象，该对象同时遵循 *可迭代的对象* 接口和 *迭代器* 接口。
```
// 自定义的数据结构
class List {
add(element) ...
get(index) ...
get size() ...
...
}
function* listIterator(list) {
for (let i = 0; i<list.size; i++) {
yield list.get(i);
}
}
const myList = new List();
myList.add(1);
myList.add(3);
from(listIterator(myList))
.subscribe(console.log);
```
```
// 结果
// 1 3 |
```
调用 `listIterator` 函数时，返回值是一个 *可迭代的对象* / *迭代器* 。函数里面的代码在调用 `subscribe` 前不会执行。
### 生成数据
你知道要发送哪些数据，但想（或者必须）动态生成它。所有函数的最后一个参数都可以用来接收一个调度器。他们产生静态的流。
#### 范围（`range`）
从初始值开始，发送一系列数字，直到完成了指定次数的迭代。
```
range(10, 2) // 从 10 开始，发送两个值
.subscribe();
```
```
// 结果
// 10 11 |
```
#### 间隔（`interval`） / 定时器（`timer`）
有点像范围，但定时器是周期性的发送累加的数字（就是说，不是立即发送）。两者的区别在于在于定时器允许你为第一个元素设定一个延迟。也可以只产生一个值，只要不指定周期。
```
interval(1000) // 每 1000ms = 1 秒 发送数据
.subscribe()
```
```
// 结果
// 0 1 2 3 4 ...
```
```
delay(5000, 1000) // 和上面相同，在开始前先等待 5000ms
delay(5000)
.subscribe(i => console.log("foo");
// 5 秒后打印 foo
```
大多数定时器将会用来周期性的处理数据：
```
interval(10000).pipe(
flatMap(i => fetch("https://server/stockTicker")
).subscribe(updateChart)
```
这段代码每 10 秒获取一次数据，更新屏幕。
#### 生成（`generate`）
这是个更加复杂的函数，允许你发送一系列任意类型的对象。它有一些重载，这里你看到的是最有意思的部分：
```
generate(
0, // 从这个值开始
x => x < 10, // 条件：只要值小于 10，就一直发送
x => x*2 // 迭代：前一个值加倍
).subscribe();
```
```
// 结果
// 1 2 4 8 |
```
你也可以用它来迭代值，如果一个结构没有实现 *可迭代的对象* 接口。我们用前面的列表例子来进行演示：
```
const myList = new List();
myList.add(1);
myList.add(3);
generate(
0, // 从这个值开始
i => i < list.size, // 条件：发送数据，直到遍历完整个列表
i => ++i, // 迭代：获取下一个索引
i => list.get(i) // 选择器：从列表中取值
).subscribe();
```
```
// 结果
// 1 3 |
```
如你所见，我添加了另一个参数：选择器。它和 `map` 操作符作用类似，将生成的值转换为更有用的东西。
### 空的流
有时候你要传递或返回一个不用发送任何数据的流。有三个函数分别用于不同的情况。你可以给这三个函数传递调度器。`empty` 和 `throwError` 接收一个调度器参数。
#### `empty`
创建一个空的流，一个值也不发送。
```
empty()
.subscribe();
```
```
// 结果
// |
```
#### `never`
创建一个永远不会结束的流，仍然不发送值。
```
never()
.subscribe();
```
```
// 结果
// ...
```
#### `throwError`
创建一个流，流出现错误，不发送数据。
```
throwError('error')
.subscribe();
```
```
// 结果
// X
```
### 挂钩已有的 API
不是所有的库和所有你之前写的代码使用或者支持流。幸运的是 RxJS 提供函数用来桥接非响应式和响应式代码。这一节仅仅讨论 RxJS 为桥接代码提供的模版。
你可能还对这篇出自 [Ben Lesh](https://medium.com/@benlesh) 的 [全面的文章](https://medium.com/@benlesh/rxjs-observable-interop-with-promises-and-async-await-bebb05306875) 感兴趣，这篇文章讲了几乎所有能与 promises 交互操作的方式。
#### `from`
我们已经用过它，把它列在这里是因为，它可以封装一个含有 observable 对象的 promise 对象。
```
from(new Promise(resolve => resolve(1)))
.subscribe();
```
```
// 结果
// 1 |
```
#### fromEvent
fromEvent 为 DOM 元素添加一个事件监听器，我确定你知道这个。但你可能不知道的是，也可以通过其它类型来添加事件监听器，例如，一个 jQuery 对象。
```
const element = $('#fooButton'); // 从 DOM 元素中创建一个 jQuery 对象
from(element, 'click')
.subscribe();
```
```
// 结果
// clickEvent ...
```
#### fromEventPattern
要理解为什么有 fromEvent 了还需要 fromEventPattern，我们得先理解 fromEvent 是如何工作的。看这段代码：
```
from(document, 'click')
.subscribe();
```
这告诉 RxJS 我们想要监听 document 中的点击事件。在提交过程中，RxJS 发现 document 是一个 *EventTarget* 类型，因此它可以调用它的 `addEventListener` 方法。如果我们传入的是一个 jQuery 对象而非 document，那么 RxJs 知道它得调用 *on* 方法。
这个例子用的是 *fromEventPattern* ，和 *fromEvent* 的工作基本上一样：
```
function addClickHandler(handler) {
document.addEventListener('click', handler);
}
function removeClickHandler(handler) {
document.removeEventListener('click', handler);
}
fromEventPattern(
addClickHandler,
removeClickHandler,
)
.subscribe(console.log);
// 等效于
fromEvent(document, 'click')
```
RxJS 自动创建实际的监听器（ *handler* ）你的工作是添加或者移除监听器。*fromEventPattern* 的目的基本上是告诉 RxJS 如何注册和移除事件监听器。
现在想象一下你使用了一个库，你可以调用一个叫做 *registerListener* 的方法。我们不能再用 *fromEvent*，因为它并不知道该怎么处理这个对象。
```
const listeners = [];
class Foo {
registerListener(listener) {
listeners.push(listener);
}
emit(value) {
listeners.forEach(listener => listener(value));
}
}
const foo = new Foo();
fromEventPattern(listener => foo.registerListener(listener))
.subscribe();
foo.emit(1);
```
```
// 结果
// 1 ...
```
当我们调用 `foo.emit(1)` 时，RxJS 中的监听器将被调用，然后它就能把值发送到流中。
你也可以用它来监听多个事件类型，或者结合所有可以通过回调进行通讯的 API，例如，WebWorker API:
```
const myWorker = new Worker('worker.js');
fromEventPattern(
handler => { myWorker.onmessage = handler },
handler => { myWorker.onmessage = undefined }
)
.subscribe();
```
```
// 结果
// workerMessage ...
```
#### bindCallback
它和 fromEventPattern 相似，但它能用于单个值。就在回调函数被调用时，流就结束了。用法当然也不一样 —— 你可以用 bindCallBack 封装函数，然后它就会在调用时魔术般的返回一个流：
```
function foo(value, callback) {
callback(value);
}
// 没有流
foo(1, console.log); //prints 1 in the console
// 有流
const reactiveFoo = bindCallback(foo);
// 当我们调用 reactiveFoo 时，它返回一个 observable 对象
reactiveFoo(1)
.subscribe(console.log); // 在控制台打印 1
```
```
// 结果
// 1 |
```
#### websocket
是的，你完全可以创建一个 websocket 连接然后把它暴露给流：
```
import { webSocket } from 'rxjs/webSocket';
let socket$ = webSocket('ws://localhost:8081');
// 接收消息
socket$.subscribe(
(msg) => console.log('message received: ' + msg),
(err) => console.log(err),
() => console.log('complete') * );
// 发送消息
socket$.next(JSON.stringify({ op: 'hello' }));
```
把 websocket 功能添加到你的应用中真的很简单。*websocket* 创建一个 subject。这意味着你可以订阅它，通过调用 `next` 来获得消息和发送消息。
#### ajax
如你所知：类似于 websocket，提供 AJAX 查询的功能。你可能用了一个带有 AJAX 功能的库或者框架。或者你没有用，那么我建议使用 fetch（或者必要的话用 polyfill），把返回的 promise 封装到一个 observable 对象中（参考稍后会讲到的 `defer` 函数）。
### 定制流
有时候已有的函数用起来并不是足够灵活。或者你需要对订阅有更强的控制。
#### 主题（`Subject`）
`Subject` 是一个特殊的对象，它使得你的能够把数据发送到流中，并且能够控制数据。`Subject` 本身就是一个可观察对象，但如果你想要把流暴露给其它代码，建议你使用 `asObservable` 方法。这样你就不能意外调用原始方法。
```
const subject = new Subject();
const observable = subject.asObservable();
observable.subscribe();
subject.next(1);
subject.next(2);
subject.complete();
```
```
// 结果
// 1 2 |
```
注意在订阅前发送的值将会“丢失”：
```
const subject = new Subject();
const observable = subject.asObservable();
subject.next(1);
observable.subscribe(console.log);
subject.next(2);
subject.complete();
```
```
// 结果
// 2
```
除了常规的 `Subject`，RxJS 还提供了三种特殊的版本。
`AsyncSubject` 在结束后只发送最后的一个值。
```
const subject = new AsyncSubject();
const observable = subject.asObservable();
observable.subscribe(console.log);
subject.next(1);
subject.next(2);
subject.complete();
```
```
// 输出
// 2
```
`BehaviorSubject` 使得你能够提供一个（默认的）值，如果当前没有其它值发送的话，这个值会被发送给每个订阅者。否则订阅者收到最后一个发送的值。
```
const subject = new BehaviorSubject(1);
const observable = subject.asObservable();
const subscription1 = observable.subscribe(console.log);
subject.next(2);
subscription1.unsubscribe();
```
```
// 输出
// 1
// 2
```
```
const subscription2 = observable.subscribe(console.log);
// 输出
// 2
```
`ReplaySubject` 存储一定数量、或一定时间或所有的发送过的值。所有新的订阅者将会获得所有存储了的值。
```
const subject = new ReplaySubject();
const observable = subject.asObservable();
subject.next(1);
observable.subscribe(console.log);
subject.next(2);
subject.complete();
```
```
// 输出
// 1
// 2
```
你可以在 [ReactiveX 文档](http://reactivex.io/documentation/subject.html)（它提供了一些其它的连接） 里面找到更多关于 `Subject` 的信息。[Ben Lesh](https://medium.com/@benlesh) 在 [On The Subject Of Subjects](https://medium.com/@benlesh/on-the-subject-of-subjects-in-rxjs-2b08b7198b93) 上面提供了一些关于 `Subject` 的理解，[Nicholas Jamieson](https://medium.com/@cartant) 在 [in RxJS: Understanding Subjects](https://blog.angularindepth.com/rxjs-understanding-subjects-5c585188c3e1) 上也提供了一些理解。
#### 可观察对象
你可以简单地用 new 操作符创建一个可观察对象。通过你传入的函数，你可以控制流，只要有人订阅了或者它接收到一个可以当成 `Subject` 使用的观察者，这个函数就会被调用，比如，调用 `next`、`complet` 和 `error`。
让我们回顾一下列表示例：
```
const myList = new List();
myList.add(1);
myList.add(3);
new Observable(observer => {
for (let i = 0; i<list.size; i++) {
observer.next(list.get(i));
}
observer.complete();
})
.subscribe();
```
```
// 结果
// 1 3 |
```
这个函数可以返回一个 `unsubcribe` 函数，当有订阅者取消订阅时这个函数就会被调用。你可以用它来清楚或者执行一些收尾操作。
```
new Observable(observer => {
// 流式化
return () => {
//clean up
};
})
.subscribe();
```
#### 继承可观察对象
在有可用的操作符前，这是一种实现自定义操作符的方式。RxJS 在内部扩展了 *可观察对象* 。`Subject` 就是一个例子，另一个是 `publisher` 操作符。它返回一个 `ConnectableObservable` 对象，该对象提供额外的方法 `connect`。
#### 实现 `Subscribable` 接口
有时候你已经用一个对象来保存状态，并且能够发送值。如果你实现了 `Subscribable` 接口，你可以把它转换成一个可观察对象。`Subscribable` 接口中只有一个 `subscribe` 方法。
```
interface Subscribable<T> { subscribe(observerOrNext?: PartialObserver<T> | ((value: T) => void), error?: (error: any) => void, complete?: () => void): Unsubscribable}
```
### 结合和选择现有的流
知道怎么创建一个独立的流还不够。有时候你有好几个流但其实只需要一个。有些函数也可作为操作符，所以我不打算在这里深入展开。推荐看看 [Max NgWizard K](https://medium.com/@maximus.koretskyi) 所写的一篇 [文章](https://blog.angularindepth.com/learn-to-combine-rxjs-sequences-with-super-intuitive-interactive-diagrams-20fce8e6511)，它还包含一些有趣的动画。
还有一个建议：你可以通过拖拽元素的方式交互式的使用结合操作，参考 [RxMarbles](http://rxmarbles.com/#merge)。
#### ObservableInput 类型
期望接收流的操作符和函数通常不单独和可观察对象一起工作。相反，它们实际上期望的参数类型是 ObservableInput，定义如下：
```
type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T> | Iterable<T>;
```
这意味着你可以传递一个 promises 或者数组却不需要事先把他们转换成可观察对象。
#### defer
主要的目的是把一个 observable 对象的创建延迟（`defer`）到有人想要订阅的时间。在以下情况，这很有用：
* 创建可观察对象的开销较大
* 你想要给每个订阅者新的可观察对象
* 你想要在订阅时候选择不同的可观察对象
* 有些代码必须在订阅之后执行
最后一点包含了一个并不起眼的用例：Promises（`defer` 也可以返回一个 promise 对象）。看看这个用到了 fetch API 的例子：
```
function getUser(id) {
console.log("fetching data");
return fetch(`https://server/user/${id}`);
}
const userPromise = getUser(1);
console.log("I don't want that request now");
// 其它地方
userPromise.then(response => console.log("done");
```
```
// 输出
// fetching data
// I don't want that request now
// done
```
只要流在你订阅的时候执行了，promise 就会立即执行。我们调用 `getUser` 的瞬间，就发送了一个请求，哪怕我们这个时候不想发送请求。当然，我们可以使用 `from` 来把一个 promise 对象转换成可观察对象，但我们传递的 promise 对象已经创建或执行了。`defer` 让我们能够等到订阅才发送这个请求：
```
const user$ = defer(() => getUser(1));
console.log("I don't want that request now");
// 其它地方
user$.subscribe(response => console.log("done");
```
```
// 输出
// I don't want that request now
// fetching data
// done
```
#### iif
`iif` 包含了一个关于 `defer` 的特殊用例：在订阅时选择两个流中的一个：
```
iif(
() => new Date().getHours() < 12,
of("AM"),
of("PM")
)
.subscribe();
```
```
// 结果
// AM before noon, PM afterwards
```
引用该文档：
>
> 实际上 [iif](https://rxjs-dev.firebaseapp.com/api/index/iif) 能够轻松地用 [defer](https://rxjs-dev.firebaseapp.com/api/index/defer) 实现，它仅仅是出于方便和可读性的目的。
>
>
>
#### onErrorResumeNext
开启第一个流并且在失败的时候继续进行下一个流。错误被忽略掉。
```
const stream1$ = of(1, 2).pipe(
tap(i => { if(i>1) throw 'error'}) //fail after first element
);
const stream2$ = of(3,4);
onErrorResumeNext(stream1$, stream2$)
.subscribe(console.log);
```
```
// 结果
// 1 3 4 |
```
如果你有多个 web 服务，这就很有用了。万一主服务器开启失败，那么备份的服务就能自动调用。
#### forkJoin
它让流并行运行，当流结束时发送存在数组中的最后的值。由于每个流只有最后一个值被发送，它一般用在只发送一个元素的流的情况，就像 HTTP 请求。你让请求并行运行，在所有流收到响应时执行某些任务。
```
function handleResponses([user, account]) {
// 执行某些任务
}
forkJoin(
fetch("https://server/user/1"),
fetch("https://server/account/1")
)
.subscribe(handleResponses);
```
#### merge / concat
发送每一个从可观察对象源中发出的值。
`merge` 接收一个参数，让你定义有多少流能被同时订阅。默认是无限制的。设为 1 就意味着监听一个源流，在它结束的时候订阅下一个。由于这是一个常见的场景，RxJS 为你提供了一个显示的函数：`concat`。
```
merge(
interval(1000).pipe(mapTo("Stream 1"), take(2)),
interval(1200).pipe(mapTo("Stream 2"), take(2)),
timer(0, 1000).pipe(mapTo("Stream 3"), take(2)),
2 //two concurrent streams
)
.subscribe();
// 只订阅流 1 和流 2
// 输出
// Stream 1 -> after 1000ms
// Stream 2 -> after 1200ms
// Stream 1 -> after 2000ms
// 流 1 结束后，开始订阅流 3
// 输出
// Stream 3 -> after 0 ms
// Stream 2 -> after 400 ms (2400ms from beginning)
// Stream 3 -> after 1000ms
merge(
interval(1000).pipe(mapTo("Stream 1"), take(2)),
interval(1200).pipe(mapTo("Stream 2"), take(2))
1
)
// 等效于
concat(
interval(1000).pipe(mapTo("Stream 1"), take(2)),
interval(1200).pipe(mapTo("Stream 2"), take(2))
)
// 输出
// Stream 1 -> after 1000ms
// Stream 1 -> after 2000ms
// Stream 2 -> after 3200ms
// Stream 2 -> after 4400ms
```
#### zip / combineLatest
`merge` 和 `concat` 一个接一个的发送所有从源流中读到的值，而 `zip` 和 `combineLatest` 是把每个流中的一个值结合起来一起发送。`zip` 结合所有源流中发送的第一个值。如果流的内容相关联，那么这就很有用。
```
zip(
interval(1000),
interval(1200),
)
.subscribe();
```
```
// 结果
// [0, 0] [1, 1] [2, 2] ...
```
`combineLatest` 与之类似，但结合的是源流中发送的最后一个值。直到所有源流至少发送一个值之后才会触发事件。这之后每次源流发送一个值，它都会把这个值与其他流发送的最后一个值结合起来。
```
combineLatest(
interval(1000),
interval(1200),
)
.subscribe();
```
```
// 结果
// [0, 0] [1, 0] [1, 1] [2, 1] ...
```
两个函数都让允许传递一个选择器函数，把元素结合成其它对象而不是数组：
```
zip(
interval(1000),
interval(1200),
(e1, e2) -> e1 + e2
)
.subscribe();
```
```
// 结果
// 0 2 4 6 ...
```
#### race
选择第一个发送数据的流。产生的流基本是最快的。
```
race(
interval(1000),
of("foo")
)
.subscribe();
```
```
// 结果
// foo |
```
由于 `of` 立即产生一个值，因此它是最快的流，然而这个流就被选中了。
### 总结
已经有很多创建可观察对象的方式了。如果你想要创造响应式的 API 或者想用响应式的 API 结合传统 API，那么了解这些方法很重要。
我已经向你展示了所有可用的方法，但它们其实还有很多内容可以讲。如果你想更加深入地了解，我极力推荐你查阅 [文档](http://reactivex.io/documentation/operators.html#creating) 或者阅读相关文章。
[RxViz](https://rxviz.com/) 是另一种值得了解的有意思的方式。你编写 RxJS 代码，产生的流可以用图形或动画进行显示。
---
via: <https://blog.angularindepth.com/the-extensive-guide-to-creating-streams-in-rxjs-aaa02baaff9a>
作者：[Oliver Flaggl](https://blog.angularindepth.com/@abetteroliver) 译者：[BriFuture](https://github.com/BriFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
理解 Python 的 Dataclasses（一）
|
Shikhar Chauhan
|
https://medium.com/mindorks/understanding-python-dataclasses-part-1-c3ccd4355c34
|
如果你正在阅读本文，那么你已经意识到了 Python 3.7 以及它所包含的新特性。就我个人而言，我对 Dataclasses 感到非常兴奋，因为我等了它一段时间了。
|
/data/attachment/album/201809/02/215843ybbbu9wemwrzazwm.png.thumb.jpg
|
/data/attachment/album/201809/02/215843ybbbu9wemwrzazwm.png
| true | false | true |
MjSeven
|
wxy
| false |
[
"Python"
] |
软件开发
|
{
"viewnum": 11046,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你正在阅读本文，那么你已经意识到了 Python 3.7 以及它所包含的新特性。就我个人而言，我对 Dataclasses 感到非常兴奋，因为我等了它一段时间了。
| 2018-09-02T21:58:40 | 2018-09-02T21:58:40 | 9,974 |
/article-9974-1.html
|
如果你正在阅读本文，那么你已经意识到了 Python 3.7 以及它所包含的新特性。就我个人而言，我对 `Dataclasses` 感到非常兴奋，因为我等了它一段时间了。
本系列包含两部分：
1. Dataclass 特点概述
2. 在下一篇文章概述 Dataclass 的 `fields`
### 介绍
`Dataclasses` 是 Python 的类（LCTT 译注：更准确的说，它是一个模块），适用于存储数据对象。你可能会问什么是数据对象？下面是定义数据对象的一个不太详细的特性列表：
* 它们存储数据并代表某种数据类型。例如：一个数字。对于熟悉 ORM 的人来说，模型实例就是一个数据对象。它代表一种特定的实体。它包含那些定义或表示实体的属性。
* 它们可以与同一类型的其他对象进行比较。例如：一个数字可以是 `greater than`（大于）、`less than`（小于） 或 `equal`（等于） 另一个数字。
当然还有更多的特性，但是这个列表足以帮助你理解问题的关键。
为了理解 `Dataclasses`，我们将实现一个包含数字的简单类，并允许我们执行上面提到的操作。
首先，我们将使用普通类，然后我们再使用 `Dataclasses` 来实现相同的结果。
但在我们开始之前，先来谈谈 `Dataclasses` 的用法。
Python 3.7 提供了一个装饰器 [dataclass](https://docs.python.org/3.7/library/dataclasses.html#dataclasses.dataclass)，用于将类转换为 `dataclass`。
你所要做的就是将类包在装饰器中：
```
from dataclasses import dataclass
@dataclass
class A:
...
```
现在，让我们深入了解一下 `dataclass` 带给我们的变化和用途。
### 初始化
通常是这样：
```
class Number:
def __init__(self, val):
self.val = val
>>> one = Number(1)
>>> one.val
>>> 1
```
用 `dataclass` 是这样：
```
@dataclass
class Number:
val:int
>>> one = Number(1)
>>> one.val
>>> 1
```
以下是 `dataclass` 装饰器带来的变化：
1. 无需定义 `__init__`，然后将值赋给 `self`，`dataclass` 负责处理它（LCTT 译注：此处原文可能有误，提及一个不存在的 `d`）
2. 我们以更加易读的方式预先定义了成员属性，以及[类型提示](https://stackoverflow.com/q/32557920/4333721)。我们现在立即能知道 `val` 是 `int` 类型。这无疑比一般定义类成员的方式更具可读性。
>
> Python 之禅: 可读性很重要
>
>
>
它也可以定义默认值：
```
@dataclass
class Number:
val:int = 0
```
### 表示
对象表示指的是对象的一个有意义的字符串表示，它在调试时非常有用。
默认的 Python 对象表示不是很直观：
```
class Number:
def __init__(self, val = 0):
self.val = val
>>> a = Number(1)
>>> a
>>> <__main__.Number object at 0x7ff395b2ccc0>
```
这让我们无法知悉对象的作用，并且会导致糟糕的调试体验。
一个有意义的表示可以通过在类中定义一个 `__repr__` 方法来实现。
```
def __repr__(self):
return self.val
```
现在我们得到这个对象有意义的表示：
```
>>> a = Number(1)
>>> a
>>> 1
```
`dataclass` 会自动添加一个 `__repr__` 函数，这样我们就不必手动实现它了。
```
@dataclass
class Number:
val: int = 0
```
```
>>> a = Number(1)
>>> a
>>> Number(val = 1)
```
### 数据比较
通常，数据对象之间需要相互比较。
两个对象 `a` 和 `b` 之间的比较通常包括以下操作：
* `a < b`
* `a > b`
* `a == b`
* `a >= b`
* `a <= b`
在 Python 中，能够在可以执行上述操作的类中定义[方法](https://docs.python.org/3/reference/datamodel.html#object.__lt__)。为了简单起见，不让这篇文章过于冗长，我将只展示 `==` 和 `<` 的实现。
通常这样写：
```
class Number:
def __init__( self, val = 0):
self.val = val
def __eq__(self, other):
return self.val == other.val
def __lt__(self, other):
return self.val < other.val
```
使用 `dataclass`：
```
@dataclass(order = True)
class Number:
val: int = 0
```
是的，就是这样简单。
我们不需要定义 `__eq__` 和 `__lt__` 方法，因为当 `order = True` 被调用时，`dataclass` 装饰器会自动将它们添加到我们的类定义中。
那么，它是如何做到的呢？
当你使用 `dataclass` 时，它会在类定义中添加函数 `__eq__` 和 `__lt__` 。我们已经知道这点了。那么，这些函数是怎样知道如何检查相等并进行比较呢？
生成 `__eq__` 函数的 `dataclass` 类会比较两个属性构成的元组，一个由自己属性构成的，另一个由同类的其他实例的属性构成。在我们的例子中，`自动`生成的 `__eq__` 函数相当于：
```
def __eq__(self, other):
return (self.val,) == (other.val,)
```
让我们来看一个更详细的例子：
我们会编写一个 `dataclass` 类 `Person` 来保存 `name` 和 `age`。
```
@dataclass(order = True)
class Person:
name: str
age:int = 0
```
自动生成的 `__eq__` 方法等同于：
```
def __eq__(self, other):
return (self.name, self.age) == ( other.name, other.age)
```
请注意属性的顺序。它们总是按照你在 `dataclass` 类中定义的顺序生成。
同样，等效的 `__le__` 函数类似于：
```
def __le__(self, other):
return (self.name, self.age) <= (other.name, other.age)
```
当你需要对数据对象列表进行排序时，通常会出现像 `__le__` 这样的函数的定义。Python 内置的 [sorted](https://docs.python.org/3.7/library/functions.html#sorted) 函数依赖于比较两个对象。
```
>>> import random
>>> a = [Number(random.randint(1,10)) for _ in range(10)] #generate list of random numbers
>>> a
>>> [Number(val=2), Number(val=7), Number(val=6), Number(val=5), Number(val=10), Number(val=9), Number(val=1), Number(val=10), Number(val=1), Number(val=7)]
>>> sorted_a = sorted(a) #Sort Numbers in ascending order
>>> [Number(val=1), Number(val=1), Number(val=2), Number(val=5), Number(val=6), Number(val=7), Number(val=7), Number(val=9), Number(val=10), Number(val=10)]
>>> reverse_sorted_a = sorted(a, reverse = True) #Sort Numbers in descending order
>>> reverse_sorted_a
>>> [Number(val=10), Number(val=10), Number(val=9), Number(val=7), Number(val=7), Number(val=6), Number(val=5), Number(val=2), Number(val=1), Number(val=1)]
```
### `dataclass` 作为一个可调用的装饰器
定义所有的 `dunder`（LCTT 译注：这是指双下划线方法，即魔法方法）方法并不总是值得的。你的用例可能只包括存储值和检查相等性。因此，你只需定义 `__init__` 和 `__eq__` 方法。如果我们可以告诉装饰器不生成其他方法，那么它会减少一些开销，并且我们将在数据对象上有正确的操作。
幸运的是，这可以通过将 `dataclass` 装饰器作为可调用对象来实现。
从官方[文档](https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass)来看，装饰器可以用作具有如下参数的可调用对象：
```
@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)
class C:
…
```
1. `init`：默认将生成 `__init__` 方法。如果传入 `False`，那么该类将不会有 `__init__` 方法。
2. `repr`：`__repr__` 方法默认生成。如果传入 `False`，那么该类将不会有 `__repr__` 方法。
3. `eq`：默认将生成 `__eq__` 方法。如果传入 `False`，那么 `__eq__` 方法将不会被 `dataclass` 添加，但默认为 `object.__eq__`。
4. `order`：默认将生成 `__gt__`、`__ge__`、`__lt__`、`__le__` 方法。如果传入 `False`，则省略它们。
我们在接下来会讨论 `frozen`。由于 `unsafe_hash` 参数复杂的用例，它值得单独发布一篇文章。
现在回到我们的用例，以下是我们需要的：
1. `__init__`
2. `__eq__`
默认会生成这些函数，因此我们需要的是不生成其他函数。那么我们该怎么做呢？很简单，只需将相关参数作为 false 传入给生成器即可。
```
@dataclass(repr = False) # order, unsafe_hash and frozen are False
class Number:
val: int = 0
>>> a = Number(1)
>>> a
>>> <__main__.Number object at 0x7ff395afe898>
>>> b = Number(2)
>>> c = Number(1)
>>> a == b
>>> False
>>> a < b
>>> Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: ‘<’ not supported between instances of ‘Number’ and ‘Number’
```
### Frozen（不可变） 实例
Frozen 实例是在初始化对象后无法修改其属性的对象。
>
> 无法创建真正不可变的 Python 对象
>
>
>
在 Python 中创建对象的不可变属性是一项艰巨的任务，我将不会在本篇文章中深入探讨。
以下是我们期望不可变对象能够做到的：
```
>>> a = Number(10) #Assuming Number class is immutable
>>> a.val = 10 # Raises Error
```
有了 `dataclass`，就可以通过使用 `dataclass` 装饰器作为可调用对象配合参数 `frozen=True` 来定义一个 `frozen` 对象。
当实例化一个 `frozen` 对象时，任何企图修改对象属性的行为都会引发 `FrozenInstanceError`。
```
@dataclass(frozen = True)
class Number:
val: int = 0
>>> a = Number(1)
>>> a.val
>>> 1
>>> a.val = 2
>>> Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
File “<string>”, line 3, in __setattr__
dataclasses.FrozenInstanceError: cannot assign to field ‘val’
```
因此，一个 `frozen` 实例是一种很好方式来存储：
* 常数
* 设置
这些通常不会在应用程序的生命周期内发生变化，任何企图修改它们的行为都应该被禁止。
### 后期初始化处理
有了 `dataclass`，需要定义一个 `__init__` 方法来将变量赋给 `self` 这种初始化操作已经得到了处理。但是我们失去了在变量被赋值之后立即需要的函数调用或处理的灵活性。
让我们来讨论一个用例，在这个用例中，我们定义一个 `Float` 类来包含浮点数，然后在初始化之后立即计算整数和小数部分。
通常是这样：
```
import math
class Float:
def __init__(self, val = 0):
self.val = val
self.process()
def process(self):
self.decimal, self.integer = math.modf(self.val)
>>> a = Float( 2.2)
>>> a.decimal
>>> 0.2000
>>> a.integer
>>> 2.0
```
幸运的是，使用 [**post\_init**](https://docs.python.org/3/library/dataclasses.html#post-init-processing) 方法已经能够处理后期初始化操作。
生成的 `__init__` 方法在返回之前调用 `__post_init__` 返回。因此，可以在函数中进行任何处理。
```
import math
@dataclass
class FloatNumber:
val: float = 0.0
def __post_init__(self):
self.decimal, self.integer = math.modf(self.val)
>>> a = Number(2.2)
>>> a.val
>>> 2.2
>>> a.integer
>>> 2.0
>>> a.decimal
>>> 0.2
```
多么方便！
### 继承
`Dataclasses` 支持继承，就像普通的 Python 类一样。
因此，父类中定义的属性将在子类中可用。
```
@dataclass
class Person:
age: int = 0
name: str
@dataclass
class Student(Person):
grade: int
>>> s = Student(20, "John Doe", 12)
>>> s.age
>>> 20
>>> s.name
>>> "John Doe"
>>> s.grade
>>> 12
```
请注意，`Student` 的参数是在类中定义的字段的顺序。
继承过程中 `__post_init__` 的行为是怎样的？
由于 `__post_init__` 只是另一个函数，因此必须以传统方式调用它：
```
@dataclass
class A:
a: int
def __post_init__(self):
print("A")
@dataclass
class B(A):
b: int
def __post_init__(self):
print("B")
>>> a = B(1,2)
>>> B
```
在上面的例子中，只有 `B` 的 `__post_init__` 被调用，那么我们如何调用 `A` 的 `__post_init__` 呢？
因为它是父类的函数，所以可以用 `super` 来调用它。
```
@dataclass
class B(A):
b: int
def __post_init__(self):
super().__post_init__() # 调用 A 的 post init
print("B")
>>> a = B(1,2)
>>> A
B
```
### 结论
因此，以上是 `dataclass` 使 Python 开发人员变得更轻松的几种方法。
我试着彻底覆盖大部分的用例，但是，没有人是完美的。如果你发现了错误，或者想让我注意相关的用例，请联系我。
我将在另一篇文章中介绍 [dataclasses.field](https://docs.python.org/3/library/dataclasses.html#dataclasses.field) 和 `unsafe_hash`。
在 [Github](http://github.com/xssChauhan/) 和 [Twitter](https://twitter.com/xssChauhan) 关注我。
更新：`dataclasses.field` 的文章可以在[这里](https://medium.com/@xsschauhan/understanding-python-dataclasses-part-2-660ecc11c9b8)找到。
---
via: <https://medium.com/mindorks/understanding-python-dataclasses-part-1-c3ccd4355c34>
作者：[Shikhar Chauhan](https://medium.com/@xsschauhan?source=post_header_lockup) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Linux 用户应该换到 BSD 的 6 个理由
|
John Paul
|
https://itsfoss.com/why-use-bsd/
|
为了准备这篇文章，我与几位 BSD 的用户聊了聊，其中有人使用了多年 Linux 而后转入 BSD。因而这篇文章的观点都来源于真实的 BSD 用户。
|
/data/attachment/album/201809/02/221951fwmfop0smowzmwx0.png.thumb.jpg
|
/data/attachment/album/201809/02/221951fwmfop0smowzmwx0.png
| true | false | true |
lujun9972
|
LuuMing
|
wxy
| false |
[
"Linux",
"BSD"
] |
观点
|
{
"viewnum": 9311,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
为了准备这篇文章，我与几位 BSD 的用户聊了聊，其中有人使用了多年 Linux 而后转入 BSD。因而这篇文章的观点都来源于真实的 BSD 用户。
| 2018-09-02T22:19:00 | 2018-09-02T22:19:00 | 9,975 |
/article-9975-1.html
|
迄今我因 BSD 是 <ruby> 自由及开源软件 <rp> （ </rp> <rt> Free and Open Source Software </rt> <rp> ） </rp></ruby> （FOSS）已经写了数篇关于它的文章。但总有人会问：“为什么要纠结于 BSD？”。我认为最好的办法是写一篇关于这个话题的文章。
### 为什么用 BSD 取代 Linux？
为了准备这篇文章，我与几位 BSD 的用户聊了聊，其中有人使用了多年 Linux 而后转入 BSD。因而这篇文章的观点都来源于真实的 BSD 用户。本文希望提出一个不同的观点。
#### 1、BSD 不仅仅是一个内核
几个人都指出 BSD 提供的操作系统对于终端用户来说就是一个巨大而统一的软件包。他们指出所谓 “Linux” 仅仅说的是内核。一个 Linux 发行版由上述的内核与许多由发行者所选取的不同的应用与软件包组成。有时候安装新的软件包所导致的不兼容会使系统产生崩溃。
一个典型的 BSD 由内核和许多必要的软件包组成。这些包里的大多数是通过活跃的项目所开发，因此其具备高集成度与高响应度的特点。
#### 2、软件包更值得信赖
说起软件包，BSD 用户提出的另一点是软件包的可信度。在 Linux 上，软件包可以从一堆不同的源上获得，一些是发行版的开发者提供的，另一些是第三方。[Ubuntu](https://itsfoss.com/snapstore-cryptocurrency-saga/) 和[其他发行版](https://www.bleepingcomputer.com/news/security/malware-found-in-arch-linux-aur-package-repository/)就遇到了在第三方应用里隐藏了恶意软件的问题。
在 BSD 上，所有的软件包由“集中式软件包/ ports 系统”所提供，“每个软件包都是单一仓库的一部分，并且每一步都设有安全系统”。这就确保了黑客不能将恶意软件潜入到看似稳定的应用程序中，保障了 BSD 的长期稳定性。
#### 3、更新缓慢 = 更好的长期稳定性
如果更新是一场竞赛，那么 Linux 就是兔子，BSD 就是乌龟。甚至最慢的 Linux 发行版每年至少发布一个新版本（当然，除了 Debian）。在 BSD 的世界里，重大版本的发布需要更长时间。这就意味着可以更关注于将事情做完善之后再将它推送给用户。
这也意味着操作系统的变化会随着时间的推移而发生。Linux 世界经历了数次快速而重大的变化，我们至今仍感觉如此（咳咳， [systemD](https://www.freedesktop.org/wiki/Software/systemd/)，咳咳）。就像 Debian 那样，长时间的开发周期可以帮助 BSD 去测试新的想法，保证在它在永久改变之前正常工作。它也有助于生产出不太可能出现问题的代码。
#### 4、Linux 太乱了
没有一个 BSD 用户直截了当地指出这一点，但这是他们许多经验所显示出的情况。很多用户从一个 Linux 发行版跳到另一个发行版去寻找适合他的版本。很多情况下，他们无法使所有的软件或硬件正常工作。这时，他们决定尝试使用 BSD，接着，所有的东西都正常工作了。
当考虑到如何选择 BSD 时，一切就变得相当简单。目前只有六个 BSD 发行版在积极开发。这些 BSD 中的每一个都有特定的用途。“[OpenBSD](https://www.openbsd.org/) 更安全，[FreeBSD](https://www.freebsd.org/) 适用于桌面或服务器，[NetBSD](http://netbsd.org/) 无所不包，[DragonFlyBSD](http://www.dragonflybsd.org/) 精简高效”。与此同时，充斥着 Linux 世界的许多发行版仅仅是在现有的发行版上增加了主题或者图标而已。BSD 项目数量之少意味着它重复性低并且更加专注。
#### 5、ZFS 支持
一个 BSD 用户说到他选择 BSD 最主要的原因是 [ZFS](https://en.wikipedia.org/wiki/ZFS)。事实上，几乎所有我谈过的人都提到 BSD 支持 ZFS 是他们没有返回 Linux 的原因。
这一点是 Linux 从一开始就处于下风的地方。虽然在一些 Linux 发行版上可以使用 [OpenZFS](http://open-zfs.org/wiki/Main_Page)，但是 ZFS 已经内置在了 BSD 的内核中。这意味着 ZFS 在 BSD 上将会有更好地性能。尽管有过将 ZFS 加入到 Linux 内核中的数次尝试，但许可证问题依旧无法解决。
#### 6、许可证
就许可证而言也有不同的看法。大多数人所持有的想法是，GPL 不是真正的自由，因为它限制了如何使用软件。一些人也认为 GPL “太庞大而复杂而难于理解，如果在开发过程中不仔细检查许可证会导致法律问题。”
另一方面，BSD 协议只有 3 条，并且允许任何人“使用软件、进行修改、做任何事，并且对开发者提供了保护”。
### 总结
这些仅仅只是一小部分人们使用 BSD 而不使用 Linux 的原因。如果你感兴趣，你可以[在这](https://discourse.trueos.org/t/why-do-you-guys-use-bsd/2601)阅读其他人的评论。如果你是 BSD 用户并且觉得我错过什么重要的地方，请在评论里说出你的想法。
如果你觉得这篇文章有意思，请在社交媒体上、技术资讯或者 [Reddit](http://reddit.com/r/linuxusersgroup) 上分享它。
---
via: <https://itsfoss.com/why-use-bsd/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LuuMing](https://github.com/LuuMing) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
基于日出和日落时间自动切换到明/暗 Gtk 主题
|
Logix
|
https://www.linuxuprising.com/2018/08/automatically-switch-to-light-dark-gtk.html
|
如果你在寻找一种基于日出和日落时间自动更改 Gtk 主题的简单方法，请尝试一下 AutomaThemely。
|
/data/attachment/album/201809/02/223426x8mw8f71f64jjfif.jpg.thumb.jpg
|
/data/attachment/album/201809/02/223426x8mw8f71f64jjfif.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"主题"
] |
分享
|
{
"viewnum": 5391,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你在寻找一种基于日出和日落时间自动更改 Gtk 主题的简单方法，请尝试一下 AutomaThemely。
| 2018-09-02T22:30:00 | 2018-09-02T22:30:00 | 9,976 |
/article-9976-1.html
|
如果你在寻找一种基于日出和日落时间自动更改 Gtk 主题的简单方法，请尝试一下 [AutomaThemely](https://github.com/C2N14/AutomaThemely)。
AutomaThemely 是一个 Python 程序，它可以根据光亮和黑暗时间自动更改 Gnome 主题，如果你想在夜间使用黑暗的 Gtk 主题并在白天使用明亮的 Gtk 主题，那么它非常有用。
**虽然该程序是为 Gnome 桌面制作的，但它也适用于 Unity**。AutomaThemely 不支持不使用 `org.gnome.desktop.interface Gsettings` 的桌面环境，如 Cinnamon，的 Gtk 主题，或者更改图标主题，至少现在还不行。它也不支持设置 Gnome Shell 主题。
除了自动更改 Gtk3 主题外，**AutomaThemely 还可以自动切换 Atom 编辑器和 VSCode 的明暗主题，以及 Atom 编辑器的明暗语法高亮。**这显然也是基于一天中的时间完成的。
*AutomaThemely Atom 和 VSCode 主题/语法设置*
程序使用你的 IP 地址来确定你的位置，以便检索日出和日落时间，并且需要有可用的 Internet 连接。但是，你可以从程序用户界面禁用自动定位，并手动输入你的位置。
在 AutomaThemely 用户界面中，你还可以输入日出和日落时间的偏移（以分钟为单位），并启用或禁用主题更改的通知。
### 下载/安装 AutomaThemely
* [下载 AutomaThemely](https://github.com/C2N14/AutomaThemely/releases)
**Ubuntu 18.04**：使用上面的链接，下载包含依赖项的 Python 3.6 DEB（`python3.6-automathemely_1.2_all.deb`）。
**Ubuntu 16.04**：你需要下载并安装 AutomaThemely Python 3.5 DEB，它不包含依赖项（`python3.5-no_deps-automathemely_1.2_all.deb`），并使用 PIP3 分别安装依赖项（`requests`、`astral`、`pytz`、`tzlocal` 和 `schedule`）：
```
sudo apt install python3-pip
python3 -m pip install --user requests astral pytz tzlocal schedule
```
AutomaThemely 下载页面还包含 Python 3.5 或 3.6 的 RPM 包，有包含和不包含依赖项两种。安装适合你的 Python 版本的软件包。如果你下载了包含依赖项的包但无法在你的系统上使用，请下载 “no\_deps” 包并如上所述使用 PIP3 安装 Python3 依赖项。
### 使用 AutomaThemely 根据太阳时间更改明亮/黑暗 Gtk 主题
安装完成后，运行 AutomaThemely 一次以生成配置文件。单击 AutomaThemely 菜单条目或在终端中运行：
```
automathemely
```
这不会运行任何 GUI，它只生成配置文件。
使用 AutomaThemely 有点反直觉。你将在菜单中看到 AutomaThemely 图标，但单击它不会打开任何窗口/GUI。如果你使用支持列表跳转/快捷列表的 Gnome 或其他基于 Gnome 的桌面，你可以右键单击菜单中的 AutomaThemely 图标（或者你可以将其固定为 Dash/dock 并在那里右键单击它）并选择 Manage Settings 启动GUI：
你还可以使用以下命令从命令行启动 AutomaThemely GUI：
```
automathemely --manage
```
**配置要使用的主题后，你需要更新太阳的时间并重新启动 AutomaThemely 调度器**。你可以通过右键单击 AutomaThemely 图标（应该在 Unity/Gnome 中可用）并选择 “Update sun times” 来更新太阳时间，然后选择 “Restart the scheduler” 来重启调度器完成此操作。你也可以使用以下命令从终端执行此操作：
```
automathemely --update
automathemely --restart
```
---
via: <https://www.linuxuprising.com/2018/08/automatically-switch-to-light-dark-gtk.html>
作者：[Logix](https://plus.google.com/118280394805678839070) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Go 编译器介绍
|
Mvdan
|
https://github.com/golang/go/blob/master/src/cmd/compile/README.md
|
cmd/compile 包含构成 Go 编译器主要的包。编译器在逻辑上可以被分为四个阶段，我们将简要介绍这几个阶段以及包含相应代码的包的列表。
|
/data/attachment/album/201809/04/110843j9uhgeq9yh88hy8e.jpg.thumb.jpg
|
/data/attachment/album/201809/04/110843j9uhgeq9yh88hy8e.jpg
| true | false | true |
stephenxs
|
wxy, pityonline
| false |
[
"Go",
"编译"
] |
技术
|
{
"viewnum": 7564,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
cmd/compile 包含构成 Go 编译器主要的包。编译器在逻辑上可以被分为四个阶段，我们将简要介绍这几个阶段以及包含相应代码的包的列表。
| 2018-09-04T11:08:50 | 2018-09-04T11:08:50 | 9,977 |
/article-9977-1.html
|
`cmd/compile` 包含构成 Go 编译器主要的包。编译器在逻辑上可以被分为四个阶段，我们将简要介绍这几个阶段以及包含相应代码的包的列表。
在谈到编译器时，有时可能会听到<ruby> 前端 <rt> front-end </rt></ruby>和<ruby> 后端 <rt> back-end </rt></ruby>这两个术语。粗略地说，这些对应于我们将在此列出的前两个和后两个阶段。第三个术语<ruby> 中间端 <rt> middle-end </rt></ruby>通常指的是第二阶段执行的大部分工作。
请注意，`go/parser` 和 `go/types` 等 `go/*` 系列的包与编译器无关。由于编译器最初是用 C 编写的，所以这些 `go/*` 包被开发出来以便于能够写出和 `Go` 代码一起工作的工具，例如 `gofmt` 和 `vet`。
需要澄清的是，名称 “gc” 代表 “<ruby> Go 编译器 <rt> Go compiler </rt></ruby>”，与大写 GC 无关，后者代表<ruby> 垃圾收集 <rt> garbage collection </rt></ruby>。
### 1、解析
* `cmd/compile/internal/syntax`（<ruby> 词法分析器 <rt> lexer </rt></ruby>、<ruby> 解析器 <rt> parser </rt></ruby>、<ruby> 语法树 <rt> syntax tree </rt></ruby>）
在编译的第一阶段，源代码被标记化（词法分析）、解析（语法分析），并为每个源文件构造语法树（LCTT 译注：这里标记指 token，它是一组预定义的、能够识别的字符串，通常由名字和值构成，其中名字一般是词法的类别，如标识符、关键字、分隔符、操作符、文字和注释等；语法树，以及下文提到的<ruby> 抽象语法树 <rt> Abstract Syntax Tree </rt></ruby>（AST），是指用树来表达程序设计语言的语法结构，通常叶子节点是操作数，其它节点是操作码）。
每个语法树都是相应源文件的确切表示，其中节点对应于源文件的各种元素，例如表达式、声明和语句。语法树还包括位置信息，用于错误报告和创建调试信息。
### 2、类型检查和 AST 变换
* `cmd/compile/internal/gc`（创建编译器 AST，<ruby> 类型检查 <rt> type-checking </rt></ruby>，<ruby> AST 变换 <rt> AST transformation </rt></ruby>）
gc 包中包含一个继承自（早期）C 语言实现的版本的 AST 定义。所有代码都是基于它编写的，所以 gc 包必须做的第一件事就是将 syntax 包（定义）的语法树转换为编译器的 AST 表示法。这个额外步骤可能会在将来重构。
然后对 AST 进行类型检查。第一步是名字解析和类型推断，它们确定哪个对象属于哪个标识符，以及每个表达式具有的类型。类型检查包括特定的额外检查，例如“声明但未使用”以及确定函数是否会终止。
特定变换也基于 AST 完成。一些节点被基于类型信息而细化，例如把字符串加法从算术加法的节点类型中拆分出来。其它一些例子是<ruby> 死代码消除 <rt> dead code elimination </rt></ruby>，<ruby> 函数调用内联 <rt> function call inlining </rt></ruby>和<ruby> 逃逸分析 <rt> escape analysis </rt></ruby>（LCTT 译注：逃逸分析是一种分析指针有效范围的方法）。
### 3、通用 SSA
* `cmd/compile/internal/gc`（转换成 SSA）
* `cmd/compile/internal/ssa`（SSA 相关的<ruby> 环节 <rt> pass </rt></ruby>和规则）
（LCTT 译注：许多常见高级语言的编译器无法通过一次扫描源代码或 AST 就完成所有编译工作，取而代之的做法是多次扫描，每次完成一部分工作，并将输出结果作为下次扫描的输入，直到最终产生目标代码。这里每次扫描称作一个<ruby> 环节 <rt> pass </rt></ruby>；最后一个环节之前所有的环节得到的结果都可称作中间表示法，本文中 AST、SSA 等都属于中间表示法。SSA，静态单赋值形式，是中间表示法的一种性质，它要求每个变量只被赋值一次且在使用前被定义）。
在此阶段，AST 将被转换为<ruby> 静态单赋值 <rt> Static Single Assignment </rt></ruby>（SSA）形式，这是一种具有特定属性的低级<ruby> 中间表示法 <rt> intermediate representation </rt></ruby>，可以更轻松地实现优化并最终从它生成机器码。
在这个转换过程中，将完成<ruby> 内置函数 <rt> function intrinsics </rt></ruby>的处理。这些是特殊的函数，编译器被告知逐个分析这些函数并决定是否用深度优化的代码替换它们（LCTT 译注：内置函数指由语言本身定义的函数，通常编译器的处理方式是使用相应实现函数的指令序列代替对函数的调用指令，有点类似内联函数）。
在 AST 转化成 SSA 的过程中，特定节点也被低级化为更简单的组件，以便于剩余的编译阶段可以基于它们工作。例如，内建的拷贝被替换为内存移动，`range` 循环被改写为 `for` 循环。由于历史原因，目前这里面有些在转化到 SSA 之前发生，但长期计划则是把它们都移到这里（转化 SSA）。
然后，一系列机器无关的规则和编译环节会被执行。这些并不考虑特定计算机体系结构，因此对所有 `GOARCH` 变量的值都会运行。
这类通用的编译环节的一些例子包括，死代码消除、移除不必要的空值检查，以及移除无用的分支等。通用改写规则主要考虑表达式，例如将一些表达式替换为常量，优化乘法和浮点操作。
### 4、生成机器码
* `cmd/compile/internal/ssa`（SSA 低级化和架构特定的环节）
* `cmd/internal/obj`（机器码生成）
编译器中机器相关的阶段开始于“低级”的编译环节，该阶段将通用变量改写为它们的特定的机器码形式。例如，在 amd64 架构中操作数可以在内存中操作，这样许多<ruby> 加载-存储 <rt> load-store </rt></ruby>操作就可以被合并。
注意低级的编译环节运行所有机器特定的重写规则，因此当前它也应用了大量优化。
一旦 SSA 被“低级化”并且更具体地针对目标体系结构，就要运行最终代码优化的编译环节了。这包含了另外一个死代码消除的环节，它将变量移动到更靠近它们使用的地方，移除从来没有被读过的局部变量，以及<ruby> 寄存器 <rt> register </rt></ruby>分配。
本步骤中完成的其它重要工作包括<ruby> 堆栈布局 <rt> stack frame layout </rt></ruby>，它将堆栈偏移位置分配给局部变量，以及<ruby> 指针活性分析 <rt> pointer liveness analysis </rt></ruby>，后者计算每个垃圾收集安全点上的哪些堆栈上的指针仍然是活动的。
在 SSA 生成阶段结束时，Go 函数已被转换为一系列 `obj.Prog` 指令。它们被传递给汇编程序（`cmd/internal/obj`），后者将它们转换为机器码并输出最终的目标文件。目标文件还将包含反射数据，导出数据和调试信息。
### 扩展阅读
要深入了解 SSA 包的工作方式，包括它的环节和规则，请转到 [cmd/compile/internal/ssa/README.md](https://github.com/golang/go/blob/master/src/cmd/compile/internal/ssa/README.md)。
---
via: <https://github.com/golang/go/blob/master/src/cmd/compile/README.md>
作者：[mvdan](https://github.com/mvdan) 译者：[stephenxs](https://github.com/stephenxs) 校对：[pityonline](https://github.com/pityonline), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
用 NodeJS 进行 Twitter 情感分析
|
Anshul Chauhan
|
https://boostlog.io/@anshulc95/twitter-sentiment-analysis-using-nodejs-5ad1331247018500491f3b6a
|
今天，我会试着让你感受下关于 Twitter 的简单 情感分析，判断这个 Twitter 是正能量、负能量还是中性的。这不会像专业人士所用的那么复杂，但至少，它会让你知道挖掘观念的想法。
|
/data/attachment/album/201809/04/114339ythtit9fz6i18jut.jpg.thumb.jpg
|
/data/attachment/album/201809/04/114339ythtit9fz6i18jut.jpg
| true | false | true |
BriFuture
|
wxy
| false |
[
"twitter",
"情感",
"数据挖掘"
] |
软件开发
|
{
"viewnum": 4428,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
今天，我会试着让你感受下关于 Twitter 的简单 情感分析，判断这个 Twitter 是正能量、负能量还是中性的。这不会像专业人士所用的那么复杂，但至少，它会让你知道挖掘观念的想法。
| 2018-09-04T11:44:13 | 2018-09-04T11:44:13 | 9,978 |
/article-9978-1.html
|
如果你想知道大家对某件事情的看法，Twitter 是最好的地方了。Twitter 是观点持续不断的涌现出来的地方，每秒钟大概有 6000 条新 Twitter 发送出来。因特网上的发展很快，如果你想与时俱进或者跟上潮流，Twitter 就是你要去的地方。
现在，我们生活在一个数据为王的时代，很多公司都善于运用 Twitter 上的数据。根据测量到的他们新产品的人气，尝试预测之后的市场趋势，分析 Twitter 上的数据有很多用处。通过数据，商人把产品卖给合适的用户，收集关于他们品牌和改进的反馈，或者获取他们产品或促销活动失败的原因。不仅仅是商人，很多政治和经济上的决定是在观察人们意见的基础上所作的。今天，我会试着让你感受下关于 Twitter 的简单 [情感分析](https://en.wikipedia.org/wiki/Sentiment_analysis)，判断这个 Twitter 是正能量、负能量还是中性的。这不会像专业人士所用的那么复杂，但至少，它会让你知道挖掘观念的想法。
我们将使用 NodeJs，因为 JavaScript 太常用了，而且它还是最容易入门的语言。
### 前置条件:
* 安装了 NodeJs 和 NPM
* 有 NodeJs 和 NPM 包的经验
* 熟悉命令行。
好了，就是这样。开始吧。
### 开始
为了你的项目新建一个目录，进入这个目录下面。打开终端（或是命令行）。进入刚创建的目录下面，运行命令 `npm init -y`。这会在这个目录下创建一个 `package.json` 文件。现在我们可以安装需要的 npm 包了。只需要创建一个新文件，命名为 `index.js` 然后我们就完成了初始的编码。
### 获取推文
好了，我们想要分析 Twitter ，为了实现这个目的，我们需要以编程的方式访问 Twitter。为此，我们要用到 [twit](https://github.com/ttezel/twit) 包。因此，先用 `npm i wit` 命令安装它。我们还需要注册一个 App，以通过我们的账户来访问 Twitter 的 API。点击这个 [链接](https://boostlog.io/@anshulc95/apps.twitter.com)，填写所有项目，从 “Keys and Access Token” 标签页中复制 “Consumer Key”、“Consumer Secret”、“Access token” 和 “Access Token Secret” 这几项到一个 `.env` 文件中，就像这样：
```
# .env
# replace the stars with values you copied
CONSUMER_KEY=************
CONSUMER_SECRET=************
ACCESS_TOKEN=************
ACCESS_TOKEN_SECRET=************
```
现在开始。
用你最喜欢的代码编辑器打开 `index.js`。我们需要用 `npm i dotenv` 命令安装 `dotenv` 包来读取 `.env` 文件。好了，创建一个 API 实例。
```
const Twit = require('twit');
const dotenv = require('dotenv');
dotenv.config();
const { CONSUMER_KEY
, CONSUMER_SECRET
, ACCESS_TOKEN
, ACCESS_TOKEN_SECRET
} = process.env;
const config_twitter = {
consumer_key: CONSUMER_KEY,
consumer_secret: CONSUMER_SECRET,
access_token: ACCESS_TOKEN,
access_token_secret: ACCESS_TOKEN_SECRET,
timeout_ms: 60*1000
};
let api = new Twit(config_twitter);
```
这里已经用所需的配置文件建立了到 Twitter 上的连接。但我们什么事情都没做。先定义个获取推文的函数：
```
async function get_tweets(q, count) {
let tweets = await api.get('search/tweets', {q, count, tweet_mode: 'extended'});
return tweets.data.statuses.map(tweet => tweet.full_text);
}
```
这是个 async 函数，因为 `api.get` 函数返回一个 promise 对象，而不是 `then` 链，我想通过这种简单的方式获取推文。它接收两个参数 `q` 和 `count`，`q` 是查询或者我们想要搜索的关键字，`count` 是让这个 `api` 返回的推文数量。
目前为止我们拥有了一个从 Twitter 上获取完整文本的简单方法。不过这里有个问题，现在我们要获取的文本中可能包含某些连接或者由于转推而被截断了。所以我们会编写另一个函数，拆解并返回推文的文本，即便是转发的推文，并且其中有链接的话就删除。
```
function get_text(tweet) {
let txt = tweet.retweeted_status ? tweet.retweeted_status.full_text : tweet.full_text;
return txt.split(/ |\n/).filter(v => !v.startsWith('http')).join(' ');
}
async function get_tweets(q, count) {
let tweets = await api.get('search/tweets', {q, count, 'tweet_mode': 'extended'});
return tweets.data.statuses.map(get_text);
}
```
现在我们拿到了文本。下一步是从文本中获取情感。为此我们会使用 `npm` 中的另一个包 —— [`sentiment`](https://www.npmjs.com/package/sentiment)。让我们像安装其他包那样安装 `sentiment`，添加到脚本中。
```
const sentiment = require('sentiment')
```
`sentiment` 用起来很简单。我们只用把 `sentiment` 函数用在我们想要分析的文本上，它就能返回文本的相对分数。如果分数小于 0，它表达的就是消极情感，大于 0 的分数是积极情感，而 0，如你所料，表示中性的情感。基于此，我们将会把推文打印成不同的颜色 —— 绿色表示积极，红色表示消极，蓝色表示中性。为此，我们会用到 [`colors`](https://www.npmjs.com/package/colors) 包。先安装这个包，然后添加到脚本中。
```
const colors = require('colors/safe');
```
好了，现在把所有东西都整合到 `main` 函数中。
```
async function main() {
let keyword = \* define the keyword that you want to search for *\;
let count = \* define the count of tweets you want *\;
let tweets = await get_tweets(keyword, count);
for (tweet of tweets) {
let score = sentiment(tweet).comparative;
tweet = `${tweet}\n`;
if (score > 0) {
tweet = colors.green(tweet);
} else if (score < 0) {
tweet = colors.red(tweet);
} else {
tweet = colors.blue(tweet);
}
console.log(tweet);
}
}
```
最后，执行 `main` 函数。
```
main();
```
就是这样，一个简单的分析推文中的基本情感的脚本。
```
\\ full script
const Twit = require('twit');
const dotenv = require('dotenv');
const sentiment = require('sentiment');
const colors = require('colors/safe');
dotenv.config();
const { CONSUMER_KEY
, CONSUMER_SECRET
, ACCESS_TOKEN
, ACCESS_TOKEN_SECRET
} = process.env;
const config_twitter = {
consumer_key: CONSUMER_KEY,
consumer_secret: CONSUMER_SECRET,
access_token: ACCESS_TOKEN,
access_token_secret: ACCESS_TOKEN_SECRET,
timeout_ms: 60*1000
};
let api = new Twit(config_twitter);
function get_text(tweet) {
let txt = tweet.retweeted_status ? tweet.retweeted_status.full_text : tweet.full_text;
return txt.split(/ |\n/).filter(v => !v.startsWith('http')).join(' ');
}
async function get_tweets(q, count) {
let tweets = await api.get('search/tweets', {q, count, 'tweet_mode': 'extended'});
return tweets.data.statuses.map(get_text);
}
async function main() {
let keyword = 'avengers';
let count = 100;
let tweets = await get_tweets(keyword, count);
for (tweet of tweets) {
let score = sentiment(tweet).comparative;
tweet = `${tweet}\n`;
if (score > 0) {
tweet = colors.green(tweet);
} else if (score < 0) {
tweet = colors.red(tweet);
} else {
tweet = colors.blue(tweet)
}
console.log(tweet)
}
}
main();
```
---
via: <https://boostlog.io/@anshulc95/twitter-sentiment-analysis-using-nodejs-5ad1331247018500491f3b6a>
作者：[Anshul Chauhan](https://boostlog.io/@anshulc95) 译者：[BriFuture](https://github.com/BriFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Python 调试器入门
|
Clément Verna
|
https://fedoramagazine.org/getting-started-python-debugger/
|
Python 标准库提供了一个名为 pdb 的调试器。此调试器提供了调试所需的大多数功能，如断点、单行步进、堆栈帧的检查等等。
|
/data/attachment/album/201809/04/120903y91t1fhy916791to.jpg.thumb.jpg
|
/data/attachment/album/201809/04/120903y91t1fhy916791to.jpg
| true | false | true |
lujun9972
|
Flowsnow
|
wxy
| false |
[
"Python",
"调试器"
] |
软件开发
|
{
"viewnum": 6286,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Python 标准库提供了一个名为 pdb 的调试器。此调试器提供了调试所需的大多数功能，如断点、单行步进、堆栈帧的检查等等。
| 2018-09-04T12:09:00 | 2018-09-04T12:09:00 | 9,979 |
/article-9979-1.html
|
Python 生态系统包含丰富的工具和库，可以让开发人员更加舒适。 例如，我们之前已经介绍了如何[使用交互式 shell 增强 Python](https://fedoramagazine.org/enhance-python-interactive-shell)。本文重点介绍另一种可以节省时间并提高 Python 技能的工具：Python 调试器。
### Python 调试器
Python 标准库提供了一个名为 pdb 的调试器。此调试器提供了调试所需的大多数功能，如断点、单行步进、堆栈帧的检查等等。
了解一些pdb 的基本知识很有用，因为它是标准库的一部分。 你可以在无法安装其他增强的调试器的环境中使用它。
#### 运行 pdb
运行 pdb 的最简单方法是从命令行，将程序作为参数传递来调试。 看看以下脚本：
```
# pdb_test.py
#!/usr/bin/python3
from time import sleep
def countdown(number):
for i in range(number, 0, -1):
print(i)
sleep(1)
if __name__ == "__main__":
seconds = 10
countdown(seconds)
```
你可以从命令行运行 pdb，如下所示：
```
$ python3 -m pdb pdb_test.py
> /tmp/pdb_test.py(1)<module>()
-> from time import sleep
(Pdb)
```
使用 pdb 的另一种方法是在程序中设置断点。为此，请导入 `pdb` 模块并使用`set_trace` 函数：
```
# pdb_test.py
#!/usr/bin/python3
from time import sleep
def countdown(number):
for i in range(number, 0, -1):
import pdb; pdb.set_trace()
print(i)
sleep(1)
if __name__ == "__main__":
seconds = 10
countdown(seconds)
```
```
$ python3 pdb_test.py
> /tmp/pdb_test.py(6)countdown()
-> print(i)
(Pdb)
```
脚本在断点处停止，pdb 显示脚本中的下一行。 你也可以在失败后执行调试器。 这称为<ruby> 事后调试 <rt> postmortem debugging </rt></ruby>。
#### 穿行于执行堆栈
调试中的一个常见用例是在执行堆栈中穿行。 Python 调试器运行后，可以使用以下命令：
* `w(here)`：显示当前执行的行以及执行堆栈的位置。
```
$ python3 test_pdb.py
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) w
/tmp/test_pdb.py(16)<module>()
-> countdown(seconds)
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb)
```
* `l(ist)`：显示当前位置周围更多的上下文（代码）。
```
$ python3 test_pdb.py
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) l
5
6
7 def countdown(number):
8 for i in range(number, 0, -1):
9 import pdb; pdb.set_trace()
10 -> print(i)
11 sleep(1)
12
13
14 if __name__ == "__main__":
15 seconds = 10
```
* `u(p)`/`d(own)`：向上或向下穿行调用堆栈。
```
$ py3 test_pdb.py
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) up
> /tmp/test_pdb.py(16)<module>()
-> countdown(seconds)
(Pdb) down
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb)
```
#### 单步执行程序
pdb提供以下命令来执行和单步执行代码：
* `n(ext)`：继续执行，直到达到当前函数中的下一行，或者返回
* `s(tep)`：执行当前行并在第一个可能的场合停止（在被调用的函数或当前函数中）
* `c(ontinue)`：继续执行，仅在断点处停止。
```
$ py3 test_pdb.py
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) n
10
> /tmp/test_pdb.py(11)countdown()
-> sleep(1)
(Pdb) n
> /tmp/test_pdb.py(8)countdown()
-> for i in range(number, 0, -1):
(Pdb) n
> /tmp/test_pdb.py(9)countdown()
-> import pdb; pdb.set_trace()
(Pdb) s
--Call--
> /usr/lib64/python3.6/pdb.py(1584)set_trace()
-> def set_trace():
(Pdb) c
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) c
9
> /tmp/test_pdb.py(9)countdown()
-> import pdb; pdb.set_trace()
(Pdb)
```
该示例显示了 `next` 和 `step` 之间的区别。 实际上，当使用 `step` 时，调试器会进入 `pdb` 模块源代码，而接下来就会执行 `set_trace` 函数。
#### 检查变量内容
* pdb 非常有用的地方是检查执行堆栈中存储的变量的内容。 例如，`a(rgs)` 命令打印当前函数的变量，如下所示：
```
py3 test_pdb.py
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) where
/tmp/test_pdb.py(16)<module>()
-> countdown(seconds)
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) args
number = 10
(Pdb)
```
pdb 打印变量的值，在本例中是 10。
* 可用于打印变量值的另一个命令是 `p(rint)`。
```
$ py3 test_pdb.py
> /tmp/test_pdb.py(10)countdown()
-> print(i)
(Pdb) list
5
6
7 def countdown(number):
8 for i in range(number, 0, -1):
9 import pdb; pdb.set_trace()
10 -> print(i)
11 sleep(1)
12
13
14 if __name__ == "__main__":
15 seconds = 10
(Pdb) print(seconds)
10
(Pdb) p i
10
(Pdb) p number - i
0
(Pdb)
```
如示例中最后的命令所示，`print` 可以在显示结果之前计算表达式。
[Python 文档](https://docs.python.org/3/library/pdb.html)包含每个 pdb 命令的参考和示例。 对于开始使用 Python 调试器人来说，这是一个有用的读物。
### 增强的调试器
一些增强的调试器提供了更好的用户体验。 大多数为 pdb 添加了有用的额外功能，例如语法突出高亮、更好的回溯和自省。 流行的增强调试器包括 [IPython 的 ipdb](https://github.com/gotcha/ipdb) 和 [pdb++](https://github.com/antocuni/pdb)。
这些示例显示如何在虚拟环境中安装这两个调试器。 这些示例使用新的虚拟环境，但在调试应用程序的情况下，应使用应用程序的虚拟环境。
#### 安装 IPython 的 ipdb
要安装 IPython ipdb，请在虚拟环境中使用 `pip`：
```
$ python3 -m venv .test_pdb
$ source .test_pdb/bin/activate
(test_pdb)$ pip install ipdb
```
要在脚本中调用 ipdb，必须使用以下命令。 请注意，该模块称为 ipdb 而不是 pdb：
```
import ipdb; ipdb.set_trace()
```
IPython 的 ipdb 也可以用 Fedora 包安装，所以你可以使用 Fedora 的包管理器 `dnf` 来安装它：
```
$ sudo dnf install python3-ipdb
```
#### 安装 pdb++
你可以类似地安装 pdb++：
```
$ python3 -m venv .test_pdb
$ source .test_pdb/bin/activate
(test_pdb)$ pip install pdbp
```
pdb++ 重写了 pdb 模块，因此你可以使用相同的语法在程序中添加断点：
```
import pdb; pdb.set_trace()
```
### 总结
学习如何使用 Python 调试器可以节省你在排查应用程序问题时的时间。 对于了解应用程序或某些库的复杂部分如何工作也是有用的，从而提高 Python 开发人员的技能。
---
via: <https://fedoramagazine.org/getting-started-python-debugger/>
作者：[Clément Verna](https://fedoramagazine.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
MPV 播放器：Linux 下的极简视频播放器
|
Abhishek Prakash
|
https://itsfoss.com/mpv-video-player/
|
MPV 是一个开源的，跨平台视频播放器，带有极简的 GUI 界面以及丰富的命令行控制。
|
/data/attachment/album/201809/05/114708iojoj1l172i1xfrl.jpg.thumb.jpg
|
/data/attachment/album/201809/05/114708iojoj1l172i1xfrl.jpg
| true | false | true |
lujun9972
|
zpl1025
|
wxy
| false |
[
"媒体播放器"
] |
分享
|
{
"viewnum": 20270,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
MPV 是一个开源的，跨平台视频播放器，带有极简的 GUI 界面以及丰富的命令行控制。
| 2018-09-05T11:47:00 | 2018-09-05T11:47:00 | 9,980 |
/article-9980-1.html
|
>
> MPV 是一个开源的，跨平台视频播放器，带有极简的 GUI 界面以及丰富的命令行控制。
>
>
>
VLC 可能是 Linux 或者其他平台下最好的视频播放器。我已经使用 VLC 很多年了，它现在仍是我最喜欢的播放器。
不过最近，我倾向于使用简洁界面的极简应用。这也是我偶然发现 MPV 的原因。我太喜欢这个软件，并把它加入了 [Ubuntu 最佳应用](https://itsfoss.com/best-ubuntu-apps/)列表里。
[MPV](https://mpv.io/) 是一个开源的视频播放器，有 Linux、Windows、MacOS、BSD 以及 Android 等平台下的版本。它实际上是从 [MPlayer](http://www.mplayerhq.hu/design7/news.html) 分支出来的。
它的图形界面只有必须的元素而且非常整洁。
### MPV 的功能
MPV 有标准播放器该有的所有功能。你可以播放各种视频，以及通过常用快捷键来控制播放。
* 极简图形界面以及必须的控件。
* 自带视频解码器。
* 高质量视频输出以及支持 GPU 硬件视频解码。
* 支持字幕。
* 可以通过命令行播放 YouTube 等流媒体视频。
* 命令行模式的 MPV 可以嵌入到网页或其他应用中。
尽管 MPV 播放器只有极简的界面以及有限的选项，但请不要怀疑它的功能。它主要的能力都来自命令行版本。
只需要输入命令 `mpv --list-options`，然后你会看到它所提供的 447 个不同的选项。但是本文不会介绍 MPV 的高级应用。让我们看看作为一个普通的桌面视频播放器，它能有多么优秀。
### 在 Linux 上安装 MPV
MPV 是一个常用应用，加入了大多数 Linux 发行版默认仓库里。在软件中心里搜索一下就可以了。
我可以确认在 Ubuntu 的软件中心里能找到。你可以在里面选择安装，或者通过下面的命令安装：
```
sudo apt install mpv
```
你可以在 [MPV 网站](https://mpv.io/installation/)上查看其他平台的安装指引。
### 使用 MPV 视频播放器
在安装完成以后，你可以通过鼠标右键点击视频文件，然后在列表里选择 MPV 来播放。
*MPV 播放器界面*
整个界面只有一个控制面板，只有在鼠标移动到播放窗口上才会显示出来。控制面板上有播放/暂停，选择视频轨道，切换音轨，字幕以及全屏等选项。
MPV 的默认大小取决于你所播放视频的画质。比如一个 240p 的视频，播放窗口会比较小，而在全高清显示器上播放 1080p 视频时，会几乎占满整个屏幕。不管视频大小，你总是可以在播放窗口上双击鼠标切换成全屏。
#### 字幕
如果你的视频带有字幕，MPV 会[自动加载字幕](https://itsfoss.com/how-to-play-movie-with-subtitles-on-samsung-tv-via-usb/)，你也可以选择关闭。不过，如果你想使用其他外挂字幕文件，不能直接在播放器界面上操作。
你可以将额外的字幕文件名改成和视频文件一样，并且将它们放在同一个目录下。MPV 会加载你的字幕文件。
更简单的播放外挂字幕的方式是，用鼠标选中文件拖到播放窗口里放开。
#### 播放 YouTube 或其他在线视频
要播放在线视频，你只能使用命令行模式的 MPV。
打开终端窗口，然后用类似下面的方式来播放：
```
mpv <URL_of_Video>
```
*在 Linux 桌面上使用 MPV 播放 YouTube 视频*
用 MPV 播放 YouTube 视频的体验不怎么好。它总是在缓冲缓冲，有点烦。
### 是否安装 MPV 播放器？
这个看你自己。如果你想体验各种应用，大可以试试 MPV。否则，默认的视频播放器或者 VLC 就足够了。
我在早些时候写关于 [Sayonara](https://itsfoss.com/sayonara-music-player/) 的文章时，并不确定大家会不会喜欢一个相对不常用的音乐播放器，但是 FOSS 的读者觉得很好。
试一下 MPV，然后看看你会不会将它作为你的默认视频播放器。
如果你喜欢 MPV，但又觉得它的图形界面需要更多功能，我推荐你使用 [GNOME MPV 播放器](https://gnome-mpv.github.io/)。
你用过 MPV 视频播放器吗？体验怎么样？喜欢还是不喜欢？欢迎在下面的评论区留言。
---
via: <https://itsfoss.com/mpv-video-player/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[zpl1025](https://github.com/zpl1025) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
极致技术探索：显卡工作原理
|
Joel Hruska
|
https://www.extremetech.com/gaming/269335-how-graphics-cards-work
|
自从 3dfx 推出最初的 Voodoo 加速器以来，不起眼的显卡对你的 PC 是否可以玩游戏起到决定性作用，PC 上任何其它设备都无法与其相比。
|
/data/attachment/album/201809/05/180925lhki9b3tk4hhwbhh.jpg.thumb.jpg
|
/data/attachment/album/201809/05/180925lhki9b3tk4hhwbhh.jpg
| true | false | true |
lujun9972
|
pinewall
|
wxy
| false |
[
"显卡",
"GPU"
] |
技术
|
{
"viewnum": 21262,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
自从 3dfx 推出最初的 Voodoo 加速器以来，不起眼的显卡对你的 PC 是否可以玩游戏起到决定性作用，PC 上任何其它设备都无法与其相比。
| 2018-09-05T18:09:00 | 2018-09-05T18:09:00 | 9,981 |
/article-9981-1.html
|
自从 3dfx 推出最初的 Voodoo 加速器以来，不起眼的显卡对你的 PC 是否可以玩游戏起到决定性作用，PC 上任何其它设备都无法与其相比。其它组件当然也很重要，但对于一个拥有 32GB 内存、价值 500 美金的 CPU 和 基于 PCIe 的存储设备的高端 PC，如果使用 10 年前的显卡，都无法以最高分辨率和细节质量运行当前<ruby> 最高品质的游戏 <rt> AAA titles </rt></ruby>，会发生卡顿甚至无响应。显卡（也常被称为 GPU，即<ruby> 图形处理单元 <rt> Graphic Processing Unit </rt></ruby>），对游戏性能影响极大，我们反复强调这一点；但我们通常并不会深入了解显卡的工作原理。
出于实际考虑，本文将概述 GPU 的上层功能特性，内容包括 AMD 显卡、Nvidia 显卡、Intel 集成显卡以及 Intel 后续可能发布的独立显卡之间共同的部分。也应该适用于 Apple、Imagination Technologies、Qualcomm、ARM 和其它显卡生产商发布的移动平台 GPU。
### 我们为何不使用 CPU 进行渲染？
我要说明的第一点是我们为何不直接使用 CPU 完成游戏中的渲染工作。坦率的说，在理论上你确实可以直接使用 CPU 完成<ruby> 渲染 <rt> rendering </rt></ruby>工作。在显卡没有广泛普及之前，早期的 3D 游戏就是完全基于 CPU 运行的，例如 《<ruby> 地下创世纪 <rt> Ultima Underworld </rt></ruby>（下文中简称 UU）。UU 是一个很特别的例子，原因如下：与《<ruby> 毁灭战士 <rt> Doom </rt></ruby>相比，UU 具有一个更高级的渲染引擎，全面支持“向上或向下看”以及一些在当时比较高级的特性，例如<ruby> 纹理映射 <rt> texture mapping </rt></ruby>。但为支持这些高级特性，需要付出高昂的代价，很少有人可以拥有真正能运行起 UU 的 PC。
*地下创世纪，图片来自 [GOG](https://www.gog.com/game/ultima_underworld_1_2)*
对于早期的 3D 游戏，包括《<ruby> 半条命 <rt> Half Life </rt></ruby>》和《<ruby> 雷神之锤 2 <rt> Quake II </rt></ruby>》在内的很多游戏，内部包含一个软件渲染器，让没有 3D 加速器的玩家也可以玩游戏。但现代游戏都弃用了这种方式，原因很简单：CPU 是设计用于通用任务的微处理器，意味着缺少 GPU 提供的<ruby> 专用硬件 <rt> specialized hardware </rt></ruby>和<ruby> 功能 <rt> capabilities </rt></ruby>。对于 18 年前使用软件渲染的那些游戏，当代 CPU 可以轻松胜任；但对于当代最高品质的游戏，除非明显降低<ruby> 景象质量 <rt> scene </rt></ruby>、分辨率和各种虚拟特效，否则现有的 CPU 都无法胜任。
### 什么是 GPU ?
GPU 是一种包含一系列专用硬件特性的设备，其中这些特性可以让各种 3D 引擎更好地执行代码，包括<ruby> 形状构建 <rt> geometry setup </rt></ruby>，纹理映射，<ruby> 访存 <rt> memory access </rt></ruby>和<ruby> 着色器 <rt> shaders </rt></ruby>等。3D 引擎的功能特性影响着设计者如何设计 GPU。可能有人还记得，AMD HD5000 系列使用 VLIW5 <ruby> 架构 <rt> archtecture </rt></ruby>；但在更高端的 HD 6000 系列中使用了 VLIW4 架构。通过 GCN （LCTT 译注：GCN 是 Graphics Core Next 的缩写，字面意思是“下一代图形核心”，既是若干代微体系结构的代号，也是指令集的名称），AMD 改变了并行化的实现方法，提高了每个时钟周期的有效性能。
*“GPU 革命”的前两块奠基石属于 AMD 和 NV；而“第三个时代”则独属于 AMD。*
Nvidia 在发布首款 GeForce 256 时（大致对应 Microsoft 推出 DirectX7 的时间点）提出了 GPU 这个术语，这款 GPU 支持在硬件上执行转换和<ruby> 光照计算 <rt> lighting calculation </rt></ruby>。将专用功能直接集成到硬件中是早期 GPU 的显著技术特点。很多专用功能还在（以一种极为不同的方式）使用，毕竟对于特定类型的工作任务，使用<ruby> 片上 <rt> on-chip </rt></ruby>专用计算资源明显比使用一组<ruby> 可编程单元 <rt> programmable cores </rt></ruby>要更加高效和快速。
GPU 和 CPU 的核心有很多差异，但我们可以按如下方式比较其上层特性。CPU 一般被设计成尽可能快速和高效的执行单线程代码。虽然 <ruby> 同时多线程 <rt> Simultaneous multithreading </rt></ruby>（SMT）或 <ruby> 超线程 <rt> Hyper-Threading </rt></ruby>（HT）在这方面有所改进，但我们实际上通过堆叠众多高效率的单线程核心来扩展多线程性能。AMD 的 32 核心/64 线程 Epyc CPU 已经是我们能买到的核心数最多的 CPU；相比而言，Nvidia 最低端的 Pascal GPU 都拥有 384 个核心。但相比 CPU 的核心，GPU 所谓的核心是处理能力低得多的的处理单元。
**注意：** 简单比较 GPU 核心数，无法比较或评估 AMD 与 Nvidia 的相对游戏性能。在同样 GPU 系列（例如 Nvidia 的 GeForce GTX 10 系列，或 AMD 的 RX 4xx 或 5xx 系列）的情况下，更高的 GPU 核心数往往意味着更高的性能。
你无法只根据核心数比较不同供应商或核心系列的 GPU 之间的性能，这是因为不同的架构对应的效率各不相同。与 CPU 不同，GPU 被设计用于并行计算。AMD 和 Nvidia 在结构上都划分为计算资源<ruby> 块 <rt> block </rt></ruby>。Nvidia 将这些块称之为<ruby> 流处理器 <rt> Streaming Multiprocessor </rt></ruby>（SM），而 AMD 则称之为<ruby> 计算单元 <rt> Compute Unit </rt></ruby>（CU）。
*一个 Pascal 流处理器（SM）。*
每个块都包含如下组件：一组核心、一个<ruby> 调度器 <rt> scheduler </rt></ruby>、一个<ruby> 寄存器文件 <rt> register file </rt></ruby>、指令缓存、纹理和 L1 缓存以及纹理<ruby> 映射单元 <rt> mapping unit </rt></ruby>。SM/CU 可以被认为是 GPU 中最小的可工作块。SM/CU 没有涵盖全部的功能单元，例如视频解码引擎，实际在屏幕绘图所需的渲染输出，以及与<ruby> 板载 <rt> onboard </rt></ruby><ruby> 显存 <rt> Video Memory </rt></ruby>（VRAM）通信相关的<ruby> 内存接口 <rt> memory interfaces </rt></ruby>都不在 SM/CU 的范围内；但当 AMD 提到一个 APU 拥有 8 或 11 个 Vega 计算单元时，所指的是（等价的）<ruby> 硅晶块 <rt> block of silicon </rt></ruby>数目。如果你查看任意一款 GPU 的模块设计图，你会发现图中 SM/CU 是反复出现很多次的部分。
*这是 Pascal 的全平面图*
GPU 中的 SM/CU 数目越多，每个时钟周期内可以并行完成的工作也越多。渲染是一种通常被认为是“高度并行”的计算问题，意味着随着核心数增加带来的可扩展性很高。
当我们讨论 GPU 设计时，我们通常会使用一种形如 4096:160:64 的格式，其中第一个数字代表核心数。在核心系列（如 GTX970/GTX 980/GTX 980 Ti，如 RX 560/RX 580 等等）一致的情况下，核心数越高，GPU 也就相对更快。
### 纹理映射和渲染输出
GPU 的另外两个主要组件是纹理映射单元和渲染输出。设计中的纹理映射单元数目决定了最大的<ruby> 纹素 <rt> texel </rt></ruby>输出以及可以多快的处理并将纹理映射到对象上。早期的 3D 游戏很少用到纹理，这是因为绘制 3D 多边形形状的工作有较大的难度。纹理其实并不是 3D 游戏必须的，但不使用纹理的现代游戏屈指可数。
GPU 中的纹理映射单元数目用 4096:160:64 指标中的第二个数字表示。AMD、Nvidia 和 Intel 一般都等比例变更指标中的数字。换句话说，如果你找到一个指标为 4096:160:64 的 GPU，同系列中不会出现指标为 4096:320:64 的 GPU。纹理映射绝对有可能成为游戏的瓶颈，但产品系列中次高级别的 GPU 往往提供更多的核心和纹理映射单元（是否拥有更高的渲染输出单元取决于 GPU 系列和显卡的指标）。
<ruby> 渲染输出单元 <rt> Render outputs </rt></ruby>（ROP），有时也叫做<ruby> 光栅操作管道 <rt> raster operations pipelines </rt></ruby>是 GPU 输出汇集成图像的场所，图像最终会在显示器或电视上呈现。渲染输出单元的数目乘以 GPU 的时钟频率决定了<ruby> 像素填充速率 <rt> pixel fill rate </rt></ruby>。渲染输出单元数目越多意味着可以同时输出的像素越多。渲染输出单元还处理<ruby> 抗锯齿 <rt> antialiasing </rt></ruby>，启用抗锯齿（尤其是<ruby> 超级采样 <rt> supersampled </rt></ruby>抗锯齿）会导致游戏填充速率受限。
### 显存带宽与显存容量
我们最后要讨论的是<ruby> 显存带宽 <rt> memory bandwidth </rt></ruby>和<ruby> 显存容量 <rt> memory capacity </rt></ruby>。显存带宽是指一秒时间内可以从 GPU 专用的显存缓冲区内拷贝进或拷贝出多少数据。很多高级视觉特效（以及更常见的高分辨率）需要更高的显存带宽，以便保证足够的<ruby> 帧率 <rt> frame rates </rt></ruby>，因为需要拷贝进和拷贝出 GPU 核心的数据总量增大了。
在某些情况下，显存带宽不足会成为 GPU 的显著瓶颈。以 Ryzen 5 2400G 为例的 AMD APU 就是严重带宽受限的，以至于提高 DDR4 的时钟频率可以显著提高整体性能。导致瓶颈的显存带宽阈值，也与游戏引擎和游戏使用的分辨率相关。
板载内存大小也是 GPU 的重要指标。如果按指定细节级别或分辨率运行所需的显存量超过了可用的资源量，游戏通常仍可以运行，但会使用 CPU 的主存来存储额外的纹理数据；而从 DRAM 中提取数据比从板载显存中提取数据要慢得多。这会导致游戏在板载的快速访问内存池和系统内存中共同提取数据时出现明显的卡顿。
有一点我们需要留意，GPU 生产厂家通常为一款低端或中端 GPU 配置比通常更大的显存，这是他们为产品提价的一种常用手段。很难说大显存是否更具有吸引力，毕竟需要具体问题具体分析。大多数情况下，用更高的价格购买一款仅是显存更高的显卡是不划算的。经验规律告诉我们，低端显卡遇到显存瓶颈之前就会碰到其它瓶颈。如果存在疑问，可以查看相关评论，例如 4G 版本或其它数目的版本是否性能超过 2G 版本。更多情况下，如果其它指标都相同，购买大显存版本并不值得。
查看我们的[极致技术探索](http://www.extremetech.com/tag/extremetech-explains)系列，深入了解更多当前最热的技术话题。
---
via: <https://www.extremetech.com/gaming/269335-how-graphics-cards-work>
作者：[Joel Hruska](https://www.extremetech.com/author/jhruska) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
查看一个归档或压缩文件的内容而无需解压它
|
Sk
|
https://www.ostechnix.com/how-to-view-the-contents-of-an-archive-or-compressed-file-without-extracting-it/
|
得益于 Linux 社区，有很多命令行工具可以来达成上面的目标。
|
/data/attachment/album/201809/05/182107w3apkh5pb3ilb33p.png.thumb.jpg
|
/data/attachment/album/201809/05/182107w3apkh5pb3ilb33p.png
| true | false | true |
lujun9972
|
FSSlc
|
wxy
| false |
[
"压缩"
] |
技术
|
{
"viewnum": 7083,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
得益于 Linux 社区，有很多命令行工具可以来达成上面的目标。
| 2018-09-05T18:21:00 | 2018-09-05T18:21:00 | 9,982 |
/article-9982-1.html
|
在本教程中，我们将学习如何在类 Unix 系统中查看一个归档或者压缩文件的内容而无需实际解压它。在深入之前，让我们先厘清归档和压缩文件的概念，它们之间有显著不同。归档是将多个文件或者目录归并到一个文件的过程，因此这个生成的文件是没有被压缩过的。而压缩则是结合多个文件或者目录到一个文件并最终压缩这个文件的方法。归档文件不是一个压缩文件，但压缩文件可以是一个归档文件，清楚了吗？好，那就让我们进入今天的主题。
### 查看一个归档或者压缩文件的内容而无需解压它
得益于 Linux 社区，有很多命令行工具可以来达成上面的目标。下面就让我们来看看使用它们的一些示例。
#### 1、使用 vim 编辑器
vim 不只是一个编辑器，使用它我们可以干很多事情。下面的命令展示的是在没有解压的情况下使用 vim 查看一个压缩的归档文件的内容：
```
$ vim ostechnix.tar.gz
```
你甚至还可以浏览归档文件的内容，打开其中的文本文件（假如有的话）。要打开一个文本文件，只需要用方向键将鼠标的游标放置到文件的前面，然后敲 ENTER 键来打开它。
#### 2、使用 tar 命令
为了列出一个 tar 归档文件的内容，可以运行：
```
$ tar -tf ostechnix.tar
ostechnix/
ostechnix/image.jpg
ostechnix/file.pdf
ostechnix/song.mp3
```
或者使用 `-v` 选项来查看归档文件的具体属性，例如它的文件所有者、属组、创建日期等等。
```
$ tar -tvf ostechnix.tar
drwxr-xr-x sk/users 0 2018-07-02 19:30 ostechnix/
-rw-r--r-- sk/users 53632 2018-06-29 15:57 ostechnix/image.jpg
-rw-r--r-- sk/users 156831 2018-06-04 12:37 ostechnix/file.pdf
-rw-r--r-- sk/users 9702219 2018-04-25 20:35 ostechnix/song.mp3
```
#### 3、使用 rar 命令
要查看一个 rar 文件的内容，只需要执行：
```
$ rar v ostechnix.rar
RAR 5.60 Copyright (c) 1993-2018 Alexander Roshal 24 Jun 2018
Trial version Type 'rar -?' for help
Archive: ostechnix.rar
Details: RAR 5
Attributes Size Packed Ratio Date Time Checksum Name
----------- --------- -------- ----- ---------- ----- -------- ----
-rw-r--r-- 53632 52166 97% 2018-06-29 15:57 70260AC4 ostechnix/image.jpg
-rw-r--r-- 156831 139094 88% 2018-06-04 12:37 C66C545E ostechnix/file.pdf
-rw-r--r-- 9702219 9658527 99% 2018-04-25 20:35 DD875AC4 ostechnix/song.mp3
----------- --------- -------- ----- ---------- ----- -------- ----
9912682 9849787 99% 3
```
#### 4、使用 unrar 命令
你也可以使用带有 `l` 选项的 `unrar` 来做到与上面相同的事情，展示如下：
```
$ unrar l ostechnix.rar
UNRAR 5.60 freeware Copyright (c) 1993-2018 Alexander Roshal
Archive: ostechnix.rar
Details: RAR 5
Attributes Size Date Time Name
----------- --------- ---------- ----- ----
-rw-r--r-- 53632 2018-06-29 15:57 ostechnix/image.jpg
-rw-r--r-- 156831 2018-06-04 12:37 ostechnix/file.pdf
-rw-r--r-- 9702219 2018-04-25 20:35 ostechnix/song.mp3
----------- --------- ---------- ----- ----
9912682 3
```
#### 5、使用 zip 命令
为了查看一个 zip 文件的内容而无需解压它，可以使用下面的 `zip` 命令：
```
$ zip -sf ostechnix.zip
Archive contains:
Life advices.jpg
Total 1 entries (597219 bytes)
```
#### 6、使用 unzip 命令
你也可以像下面这样使用 `-l` 选项的 `unzip` 命令来呈现一个 zip 文件的内容：
```
$ unzip -l ostechnix.zip
Archive: ostechnix.zip
Length Date Time Name
--------- ---------- ----- ----
597219 2018-04-09 12:48 Life advices.jpg
--------- -------
597219 1 file
```
#### 7、使用 zipinfo 命令
```
$ zipinfo ostechnix.zip
Archive: ostechnix.zip
Zip file size: 584859 bytes, number of entries: 1
-rw-r--r-- 6.3 unx 597219 bx defN 18-Apr-09 12:48 Life advices.jpg
1 file, 597219 bytes uncompressed, 584693 bytes compressed: 2.1%
```
如你所见，上面的命令展示了一个 zip 文件的内容、它的权限、创建日期和压缩百分比等等信息。
#### 8、使用 zcat 命令
要一个压缩的归档文件的内容而不解压它，使用 `zcat` 命令，我们可以得到：
```
$ zcat ostechnix.tar.gz
```
`zcat` 和 `gunzip -c` 命令相同。所以你可以使用下面的命令来查看归档或者压缩文件的内容：
```
$ gunzip -c ostechnix.tar.gz
```
#### 9、使用 zless 命令
要使用 zless 命令来查看一个归档或者压缩文件的内容，只需：
```
$ zless ostechnix.tar.gz
```
这个命令类似于 `less` 命令，它将一页一页地展示其输出。
#### 10、使用 less 命令
可能你已经知道 `less` 命令可以打开文件来交互式地阅读它，并且它支持滚动和搜索。
运行下面的命令来使用 `less` 命令查看一个归档或者压缩文件的内容：
```
$ less ostechnix.tar.gz
```
上面便是全部的内容了。现在你知道了如何在 Linux 中使用各种命令查看一个归档或者压缩文件的内容了。希望本文对你有用。更多好的内容将呈现给大家，希望继续关注我们！
干杯！
---
via: <https://www.ostechnix.com/how-to-view-the-contents-of-an-archive-or-compressed-file-without-extracting-it/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[FSSlc](https://github.com/FSSlc) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
FreeDOS 的简单介绍
|
Jim Hall
|
https://opensource.com/article/18/4/gentle-introduction-freedos
|
学习如何穿行于 C:\ 提示符下，就像上世纪 90 年代的 DOS 高手一样。
|
/data/attachment/album/201809/05/203949lr4q42rc6e4pp9s2.png.thumb.jpg
|
/data/attachment/album/201809/05/203949lr4q42rc6e4pp9s2.png
| true | false | true |
lujun9972
|
icecoobe
|
wxy
| false |
[
"FreeDOS",
"DOS"
] |
技术
|
{
"viewnum": 17889,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习如何穿行于 C:\ 提示符下，就像上世纪 90 年代的 DOS 高手一样。
| 2018-09-05T20:39:42 | 2018-09-05T20:39:42 | 9,983 |
/article-9983-1.html
|
>
> 学习如何穿行于 C:\ 提示符下，就像上世纪 90 年代的 DOS 高手一样。
>
>
>
FreeDOS 是一个古老的操作系统，但是对于多数人而言它又是陌生的。在 1994 年，我和几个开发者一起 [开发了 FreeDOS](https://opensource.com/article/17/10/freedos) —— 这是一个完整、自由、兼容 DOS 的操作系统，你可以用它来玩经典的 DOS 游戏、运行过时的商业软件或者开发嵌入式系统。任何在 MS-DOS 下工作的程序在 FreeDOS 下也可以运行。
在 1994 年，任何一个曾经使用过微软的商业版 MS-DOS 的人都会迅速地熟悉 FreeDOS。这是设计而为之的；FreeDOS 尽可能地去模仿 MS-DOS。结果，1990 年代的 DOS 用户能够直接转换到 FreeDOS。但是，时代变了。今天，开源的开发者们对于 Linux 命令行更熟悉，或者他们可能倾向于像 [GNOME](https://opensource.com/article/17/8/gnome-20-anniversary) 一样的图形桌面环境，这导致 FreeDOS 命令行界面最初看起来像个异类。
新的用户通常会问，“我已经安装了 [FreeDOS](http://www.freedos.org/)，但是如何使用呢？”。如果你之前并没有使用过 DOS，那么闪烁的 `C:\>` DOS 提示符看起来会有点不太友好，而且可能有点吓人。这份 FreeDOS 的简单介绍将带你起步。它只提供了基础：如何浏览以及如何查看文件。如果你想了解比这里提及的更多的知识，访问 [FreeDOS 维基](http://wiki.freedos.org/)。
### DOS 提示符
首先，让我们看一下空的提示符以及它的含义。
DOS 是在个人电脑从软盘运行时期创建的一个“<ruby> 磁盘操作系统 <rt> disk operating system </rt></ruby>”。甚至当电脑支持硬盘了，在 1980 年代和 1990 年代，频繁地在不同的驱动器之间切换也是很普遍的。举例来说，你可能想将最重要的文件都备份一份拷贝到软盘中。
DOS 使用一个字母来指代每个驱动器。早期的电脑仅拥有两个软盘驱动器，他们被分配了 `A:` 和 `B:` 盘符。硬盘上的第一个分区盘符是 `C:` ，然后其它的盘符依次这样分配下去。提示符中的 `C:` 表示你正在使用第一个硬盘的第一个分区。
从 1983 年的 PC-DOS 2.0 开始，DOS 也支持目录和子目录，非常类似 Linux 文件系统中的目录和子目录。但是跟 Linux 不一样的是，DOS 目录名由 `\` 分隔而不是 `/`。将这个与驱动器字母合起来看，提示符中的 `C:\` 表示你正在 `C:` 盘的顶端或者“根”目录。
`>` 符号是提示你输入 DOS 命令的地方，就像众多 Linux shell 的 `$`。`>` 前面的部分告诉你当前的工作目录，然后你在 `>` 提示符这输入命令。
### 在 DOS 中找到你的使用方式
在 DOS 中浏览目录的基本方式和你在 Linux 命令行下的步骤非常相似。你仅需要记住少数的命令。
#### 显示一个目录
当你想要查看当前目录的内容时，使用 `DIR` 命令。因为 DOS 命令是大小写不敏感的，你也可以输入 `dir`。默认地，DOS 会显示每个文件和子目录的细节，包括了名字、扩展类型、大小以及最后一次更改的日期和时间。
如果你不想显示单个文件大小的额外细节，你可以在 `DIR` 命令中使用 `/w` 选项来显示一个“宽”的目录列表。注意，Linux 用户使用连字号（`-`）或者双连字号（`--`）来开始命令行选项，而 DOS 使用斜线字符（`/`）。
你可以将特定子目录的路径名作为参数传递给 `DIR` 命令来查看它。此外，另一个与 Linux 系统的区别是 Linux 文件和目录是大小写敏感的，而 DOS 下的名称是大小写不敏感的。DOS 通常将文件和目录使用全部大写的方式显示，不过你可以等同地用小写格式来使用它们。
#### 切换当前工作目录
一旦你能够查看一个目录的内容，你就能够“移动到”任何其它的目录。在 DOS 上，使用 `CHDIR` 命令来切换工作目录，也可以简写为 `CD`。你可以使用类似 `CD CHOICE` 的命令进入到一个子目录或者使用 `CD \FDOS\DOC\CHOICE` 进入到一个新的路径。
就像在 Linux 命令行，DOS 使用 `.` 来表示当前目录，而 `..` 表示父目录（当前目录的上一级）。你可以将这些组合起来使用。比如，`CD ..` 进入到父目录，然后 `CD ..\..` 由当前目录做两个“向上”目录级别的操作。
FreeDOS 也从 Linux 那借鉴了一些特性：你可以使用 `CD -` 跳转回之前的工作目录。在你进入一个新的路径做完一件事之后，想要回退到之前工作状态的情况下，这会很方便。
#### 切换当前工作盘符
在 Linux 下，“磁盘”的概念是隐藏的。在 Linux 和其它 Unix 系统中，你“挂载”磁盘到一个目录，例如 `/backup`，或者系统自动帮你完成，比如 `/var/run/media/user/flashdrive`。但是 DOS 是一个相对简单的系统。使用 DOS，你必须自行更改工作磁盘。
记住 DOS 分配第一块硬盘的第一个分区为 `C:` 盘，然后这样依次分配其它盘符。在现代系统中，人们很少将硬盘分割成多个 DOS 分区；他们简单地使用整个磁盘或者尽可能多地分配给 DOS。如今 `C:` 通常是第一块硬盘，而 `D:` 通常是另一块硬盘或者 CD-ROM 驱动器。其它的网络磁盘驱动器也可以被映射到别的盘符，比如 `E:` 或者 `Z:` 或者任何你想要的组织方式。
在 DOS 下切换磁盘很容易。只要在命令行输入盘符后附加一个冒号（`:`），然后 DOS 就会切换到该工作磁盘。举例来说，在我的 [QEMU](https://www.qemu.org/) 系统上，我将 `D:` 设置到我的 Linux 主目录下的一个共享目录，那里存放了各种我想测试的 DOS 应用程序和游戏的安装文件。
小心不要尝试切换到一个不存在的磁盘。DOS 可能会将它设置为工作磁盘，但是如果你尝试在那做任何事，你将会遇到略微臭名昭著的“<ruby> 退出、重试、失败 <rt> Abort, Retry, Fail </rt></ruby>” DOS 错误信息。
### 其它可以尝试的事情
使用 `CD` 和 `DIR` 命令，你就拥有了基础的浏览 DOS 能力。这些命令允许你查找 DOS 目录并查看其他子目录和文件的存在。一旦你熟悉基础浏览操作，你还可以尝试其它的这些基础 DOS 命令：
* `MKDIR` 或 `MD` 创建新的目录
* `RMDIR` 或 `RD` 删除目录
* `TREE` 以树状格式显示目录和子目录列表
* `TYPE` 和 `MORE` 显示文件内容
* `RENAME` 或 `REN` 重命名文件
* `DEL` 或 `ERASE` 删除文件
* `EDIT` 编辑文件
* `CLS` 清除屏幕
如果这些还不够，你可以在 FreeDOS 维基上面找到[所有 DOS 命令](http://wiki.freedos.org/wiki/index.php/Dos_commands)的清单。
在 FreeDOS 下，针对每个命令你都能够使用 `/?` 参数来获取简要的说明。举例来说，`EDIT /?` 会告诉你编辑器的用法和选项。或者你可以输入 `HELP` 来使用交互式帮助系统。
像任何一个 DOS 一样，FreeDOS 被认为是一个简单的操作系统。仅使用一些基本命令就可以轻松浏览 DOS 文件系统。那么，启动一个 QEMU 会话，安装 FreeDOS，然后尝试一下 DOS 命令行界面吧。也许它现在看起来就没那么吓人了。
---
via: <https://opensource.com/article/18/4/gentle-introduction-freedos>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 选题：[lujun9972](https://github.com/lujun9972) 译者：[icecoobe](https://github.com/icecoobe) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 虚拟机与 Linux Live 镜像
|
Matt Hartley
|
https://www.datamation.com/open-source/linux-virtual-machines-vs-linux-live-images.html
|
Linux 虚拟机与 Linux Live 镜像各有优势，也有不足。
|
/data/attachment/album/201809/06/215123eskveknnsnpfnnns.jpg.thumb.jpg
|
/data/attachment/album/201809/06/215123eskveknnsnpfnnns.jpg
| true | false | true |
sober-wang
|
wxy
| false |
[
"Linux",
"发行版",
"镜像"
] |
观点
|
{
"viewnum": 9013,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 虚拟机与 Linux Live 镜像各有优势，也有不足。
| 2018-09-06T21:51:00 | 2018-09-06T21:51:00 | 9,984 |
/article-9984-1.html
|
>
> Linux 虚拟机与 Linux Live 镜像各有优势，也有不足。
>
>
>
首先我得承认，我非常喜欢频繁尝试新的 [Linux 发行版本](https://www.datamation.com/open-source/best-linux-distro.html)。然而，我用来测试它们的方法根据每次目标而有所不同。在这篇文章中，我们来看看两种运行 Linux 的模式：虚拟机或 Live 镜像。每一种方式都存在优势，但是也有一些不足。
### 首次测试一个全新的 Linux 发行版
当我首次测试一个全新 Linux 发行版时，我使用的方法很大程度上依赖于我当前所拥有的 PC 资源。如果我使用台式机，我会在一台虚拟机中运行该发行版来测试。使用这种方法的原因是，我可以下载并测试该发行版，不只是在一个 Live 环境中，而且也可以作为一个带有持久存储的安装的系统。
另一方面，如果我的 PC 不具备强劲的硬件，那么通过 Linux 的虚拟机安装来测试发行版是适得其反的。我会将那台 PC 压榨到它的极限，诚然，更好的是使用 Linux Live 镜像，而不是从闪存盘中运行。
### 体验新的 Linux 发行版本的软件
如果你有兴趣查看发行版本的桌面环境或可用的软件，那使用它的 Live 镜像就没错了。一个 Live 环境可以提供给你所预期的全局视角、其所提供的软件和用户体验的整体感受。
公平的说，你也可以在虚拟机上达到同样的效果，但是它有一点不好，如果这么做会让更多数据填满你的磁盘空间。毕竟这只是对发行版的一个简单体验。记得我在第一节说过：我喜欢在虚拟机上运行 Linux 来做测试。用这个方式我就能看到如何去安装它、分区是怎么样的等等，而使用 Live 镜像时你就看不到这些。
这种体验方式通常表明你只想对该发行版本有个大致了解，所以在这种情况下，这种只需要付出最小的精力和时间的方式是一种不错的办法。
### 随身携带一个发行版
这种方式虽然不像几年前那样普遍，这种随身携带一个 Linux 发行版的能力也许是出于对某些用户的考虑。显然，虚拟机安装对于便携性并无太多帮助。不过， Live 镜像实际上是十分便携的。 Live 镜像可以写入到 DVD 当中或复制到一个闪存盘中而便于携带。
从 Linux 的便携性这个概念上展开来说，当要在一个朋友的电脑上展示 Linux 如何工作，使用一个闪存盘上的 Live 镜像也是很方便的。这可以使你能演示 Linux 如何丰富他们的生活，而不用必须在他们的 PC 上运行一个虚拟机。使用 Live 镜像这就有点双赢的感觉了。
### 选择做双引导 Linux
这接下来的方式是个大工程。考虑一下，也许你是一个 Windows 用户。你喜欢玩 Linux，但又不愿意冒险。除了在某些情况下会出些状况或者识别个别分区时遇到问题，双引导方式就没啥挑剔的。无论如何，使用 Linux 虚拟机或 Live 镜像都对于你来说是一个很好的选择。
现在，我在某些事情上采取了不同的立场。我认为长期在闪存盘上运行 Live 镜像要比虚拟机更有价值。这有两个原因。首先，您将会习惯于真正运行 Linux，而不是在 Windows 之上的虚拟机中运行它。其次，您可以设置闪存盘以包含持久存储的用户数据。
我知道你会说用一个虚拟机运行 Linux 也是如此，然而，使用 Live 镜像的方式，你绝不会因为更新而被破坏任何东西。为什么？因为你不会更新你的宿主系统或者客户系统。请记住，有整个 Linux 发行版本被设计为持久存储的 Linux 发行版。Puppy Linux 就是一个非常好的例子。它不仅能运行在要被回收或丢弃的个人 PC 上，它也可以让你永远不被频繁的系统升级所困扰，这要感谢该发行版处理安全更新的方式。这不是一个常规的 Linux 发行版，而是以这样的一种方式封闭了安全问题——即持久存储的 Live 镜像中没有什么令人担心的坏东西。
### Linux 虚拟机绝对是一个最好的选择
在我结束这篇文章时，让我告诉你。有一种场景下，使用 Virtual Box 等虚拟机绝对比 Live 镜像更好：记录 Linux 发行版的桌面环境。
例如，我制作了一个视频，里面介绍和点评了许多 Linux 发行版。使用 Live 镜像进行此操作需要我用硬件设备捕获屏幕，或者从 Live 镜像的软件仓库中安装捕获软件。显然，虚拟机比 Linux 发行版的 Live 镜像更适合这项工作。
一旦你需要采集音频进行混音，毫无疑问，如果您要使用软件来捕获您的点评语音，那么您肯定希望拥有一个宿主操作系统，里面包含了一个起码的捕获环境的所有基本需求。同样，您可以使用硬件设备来完成所有这一切，但如果您只是做兼职的视频/音频捕获， 那么这可能要付出成本高昂的代价。
### Linux 虚拟机 VS. Linux Live 镜像
你最喜欢尝试新发行版的方式是哪些？也许，你是那种可以很好地格式化磁盘、将风险置之脑后的人，所以这里说的这些都是没用的？
我在网上互动的大多数人都倾向于遵循我上面提及的方法，但是我很想知道哪种方式更加适合你。点击评论框，让我知道在体验 Linux 发行版世界最伟大和最新的版本时，您更喜欢哪种方法。
---
via: <https://www.datamation.com/open-source/linux-virtual-machines-vs-linux-live-images.html>
作者：[Matt Hartley](https://www.datamation.com/author/Matt-Hartley-3080.html) 译者：[sober-wang](https://github.com/sober-wang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何在 Linux 中不使用功能键在 TTY 之间切换
|
Sk
|
https://www.ostechnix.com/how-to-switch-between-ttys-without-using-function-keys-in-linux/
|
当任何一个功能键不起作用时，chvt 命令会很有用。
|
/data/attachment/album/201809/06/221052uimitj7mmytji0si.png.thumb.jpg
|
/data/attachment/album/201809/06/221052uimitj7mmytji0si.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"TTY",
"终端"
] |
技术
|
{
"viewnum": 13335,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当任何一个功能键不起作用时，chvt 命令会很有用。
| 2018-09-06T22:10:51 | 2018-09-06T22:10:51 | 9,985 |
/article-9985-1.html
|
本简要指南介绍了在类 Unix 操作系统中如何在不使用功能键的情况下切换 TTY。在进一步讨论之前，我们将了解 TTY 是什么。正如在 AskUbuntu 论坛的一个[答案](https://askubuntu.com/questions/481906/what-does-tty-stand-for)中所提到的，**TTY**这个词来自 **T**ele**TY**pewriter（电传打字机）。在 Unix 的早期，连接到计算机的用户终端就是机电的电传机或电传打字机（简称 tty）。从那时起，TTY 这个名称继续用于纯文本控制台。如今，所有文本控制台都代表虚拟控制台，而不是物理控制台。TTY 命令打印连接到标准输入的终端的文件名。
### 在 Linux 中切换 TTY
默认情况下，Linux 中有 7 个 tty。它们被称为 tty1、tty2……tty7。1 到 6 的 tty 只是命令行。第 7 个 tty 是 GUI（你的 X 桌面会话）。你可以使用 `CTRL+ALT+Fn` 键在不同的 TTY 之间切换。例如，要切换到 tty1，我们按下 `CTRL+ALT+F1`。这就是 tty1 在 Ubuntu 18.04 LTS 服务器中的样子。
如果你的系统没有 X 会话， 只需要按下 `Alt+Fn` 键，不需要按下 `CTRL`。
在某些 Linux 版本中（例如，从 Ubuntu 17.10 开始），登录屏开始使用 1 号虚拟控制台。因此，你需要按 `CTRL+ALT+F3` 到 `CTRL+ALT+F6` 来访问虚拟控制台。要返回桌面环境，请在 Ubuntu 17.10 及更高版本上按下 `CTRL+ALT+F2` 或 `CTRL+ALT+F7`。
目前为止我们看到我们可以使用 `CTRL+ALT+Fn`（`F1` - `F7`）在 TTY 之间轻松切换。但是，如果出于任何原因你不想使用功能键，那么在 Linux 中有一个名为 `chvt` 的简单命令。
`chvt N` 命令让你切换到前台终端 N，这与按 `CTRL+ALT+Fn` 相同。如果它不存在，则创建相应的屏幕。
让我们试试显示当前的 tty：
```
$ tty
```
我的 Ubuntu 18.04 LTS 服务器的示例输出。
现在让我们切换到 tty2。为此，请输入：
```
$ sudo chvt 2
```
记住你需要在 `chvt` 命令一同使用 `sudo`。
现在，使用命令检查当前的 tty：
```
$ tty
```
你会看到 tty 现在已经改变了。
同样，你可以使用 `sudo chvt 3` 切换到 tty3，使用 `sudo chvt 4` 切换到 tty4 等等。
当任何一个功能键不起作用时，`chvt` 命令会很有用。
要查看活动虚拟控制台的总数，请运行：
```
$ fgconsole
2
```
如你所见，我的系统中有两个活动的虚拟终端。
你可以使用以下命令查看下一个未分配的虚拟终端：
```
$ fgconsole --next-available
3
```
如果虚拟控制台不是前台控制台，并且它没有打开任何进程来读取或写入，并且未在其屏幕上选择任何文本，则它是未使用的。
要移除未使用的虚拟终端，只需键入：
```
$ deallocvt
```
上面的命令为所有未使用的虚拟控制台释放内核内存和数据结构。简单地说，此命令将释放连接到未使用的虚拟控制台的所有资源。
有关更多详细信息，请参阅相应命令的手册页。
```
$ man tty
$ man chvt
$ man fgconsole
$ man deallocvt
```
就是这些了。希望这很有用。还有更多的好东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-switch-between-ttys-without-using-function-keys-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Ubuntu 系统中添加一个辅助 IP 地址
|
Prakash Subramanian
|
https://www.2daygeek.com/how-to-add-additional-ip-secondary-ip-in-ubuntu-debian-system/
|
我们不应在服务器主 IP 地址上托管任何应用程序，这是不可取的。如果要在服务器上托管任何应用程序，我们应该为此添加辅助 IP。
|
/data/attachment/album/201809/06/223001q55t4bqttuqkgnpu.jpg.thumb.jpg
|
/data/attachment/album/201809/06/223001q55t4bqttuqkgnpu.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"IP"
] |
技术
|
{
"viewnum": 9983,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们不应在服务器主 IP 地址上托管任何应用程序，这是不可取的。如果要在服务器上托管任何应用程序，我们应该为此添加辅助 IP。
| 2018-09-06T22:30:08 | 2018-09-06T22:30:08 | 9,986 |
/article-9986-1.html
|
Linux 管理员应该意识到这一点，因为这是一项例行任务。很多人想知道为什么我们需要在服务器中添加多个 IP 地址，以及为什么我们需要将它添加到单块网卡中？我说的对吗？
你可能也会有类似的问题：在 Linux 中如何为单块网卡分配多个 IP 地址？在本文中，你可以得到答案。
当我们对一个新服务器进行设置时，理想情况下它将有一个 IP 地址，即服务器主 IP 地址，它与服务器主机名对应。
我们不应在服务器主 IP 地址上托管任何应用程序，这是不可取的。如果要在服务器上托管任何应用程序，我们应该为此添加辅助 IP。
这是业界的最佳实践，它允许用户安装 SSL 证书。大多数系统都配有单块网卡，这足以添加额外的 IP 地址。
**建议阅读：**
* [在 Linux 命令行中 9 种方法检查公共 IP 地址](https://www.2daygeek.com/check-find-server-public-ip-address-linux/)
* [在 Linux 终端中 3 种简单的方式来检查 DNS（域名服务器）记录](https://www.2daygeek.com/check-find-dns-records-of-domain-in-linux-terminal/)
* [在 Linux 上使用 Dig 命令检查 DNS（域名服务器）记录](https://www.2daygeek.com/dig-command-check-find-dns-records-lookup-linux/)
* [在 Linux 上使用 Nslookup 命令检查 DNS（域名服务器）记录](https://www.2daygeek.com/nslookup-command-check-find-dns-records-lookup-linux/)
* [在 Linux 上使用 Host 命令检查 DNS（域名服务器）记录](https://www.2daygeek.com/host-command-check-find-dns-records-lookup-linux/)
我们可以在同一个接口上添加 IP 地址，或者在同一设备上创建子接口，然后在其中添加 IP。默认情况下，一直到 Ubuntu 14.04 LTS，接口给名称为 `ethX (eth0)`，但是从 Ubuntu 15.10 之后网络接口名称已从 `ethX` 更改为 `enXXXXX`（对于服务器是 ens33，桌面版是 enp0s3）。
在本文中，我们将教你如何在 Ubuntu 上执行此操作，并且衍生到其它发行版（to 校正：这句自己加的）。
**注意：**别在 DNS 详细信息后添加 IP 地址。如果是这样，DNS 将无法正常工作。
### 如何在 Ubuntu 14.04 LTS 中添加临时辅助 IP 地址
在系统中添加 IP 地址之前，运行以下任一命令即可验证服务器主 IP 地址：
```
# ifconfig
或
# ip addr
# ip addr
eth0 Link encap:Ethernet HWaddr 08:00:27:98:b7:36
inet addr:192.168.56.150 Bcast:192.168.56.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fe98:b736/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:4 errors:0 dropped:0 overruns:0 frame:0
TX packets:105 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:902 (902.0 B) TX bytes:16423 (16.4 KB)
eth1 Link encap:Ethernet HWaddr 08:00:27:6a:cf:d3
inet addr:10.0.3.15 Bcast:10.0.3.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fe6a:cfd3/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:80 errors:0 dropped:0 overruns:0 frame:0
TX packets:146 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:8698 (8.6 KB) TX bytes:17047 (17.0 KB)
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:25 errors:0 dropped:0 overruns:0 frame:0
TX packets:25 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1
RX bytes:1730 (1.7 KB) TX bytes:1730 (1.7 KB)
```
如我所见，服务器主 IP 地址是 `192.168.56.150`，我将下一个 IP `192.168.56.151` 作为辅助 IP，使用以下方法完成：
```
# ip addr add 192.168.56.151/24 broadcast 192.168.56.255 dev eth0 label eth0:1
```
输入以下命令以检查新添加的 IP 地址。如果你重新启动服务器，那么新添加的 IP 地址会消失，因为我们的 IP 是临时添加的。
```
# ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:98:b7:36 brd ff:ff:ff:ff:ff:ff
inet 192.168.56.150/24 brd 192.168.56.255 scope global eth0
valid_lft forever preferred_lft forever
inet 192.168.56.151/24 brd 192.168.56.255 scope global secondary eth0:1
valid_lft forever preferred_lft forever
inet6 fe80::a00:27ff:fe98:b736/64 scope link
valid_lft forever preferred_lft forever
3: eth1: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:6a:cf:d3 brd ff:ff:ff:ff:ff:ff
inet 10.0.3.15/24 brd 10.0.3.255 scope global eth1
valid_lft forever preferred_lft forever
inet6 fe80::a00:27ff:fe6a:cfd3/64 scope link
valid_lft forever preferred_lft forever
```
### 如何在 Ubuntu 14.04 LTS 中添加永久辅助 IP 地址
要在 Ubuntu 系统上添加永久辅助 IP 地址，只需编辑 `/etc/network/interfaces` 文件并添加所需的 IP 详细信息。
```
# vi /etc/network/interfaces
```
```
# vi /etc/network/interfaces
# The loopback network interface
auto lo
iface lo inet loopback
# The primary network interface
auto eth0
iface eth0 inet static
address 192.168.56.150
netmask 255.255.255.0
network 192.168.56.0
broadcast 192.168.56.255
gateway 192.168.56.1
auto eth0:1
iface eth0:1 inet static
address 192.168.56.151
netmask 255.255.255.0
```
保存并关闭文件，然后重启网络接口服务。
```
# service networking restart
或
# ifdown eth0:1 && ifup eth0:1
```
验证新添加的 IP 地址：
```
# ifconfig
eth0 Link encap:Ethernet HWaddr 08:00:27:98:b7:36
inet addr:192.168.56.150 Bcast:192.168.56.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fe98:b736/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:5 errors:0 dropped:0 overruns:0 frame:0
TX packets:84 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:962 (962.0 B) TX bytes:11905 (11.9 KB)
eth0:1 Link encap:Ethernet HWaddr 08:00:27:98:b7:36
inet addr:192.168.56.151 Bcast:192.168.56.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
eth1 Link encap:Ethernet HWaddr 08:00:27:6a:cf:d3
inet addr:10.0.3.15 Bcast:10.0.3.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fe6a:cfd3/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:4924 errors:0 dropped:0 overruns:0 frame:0
TX packets:3185 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:4037636 (4.0 MB) TX bytes:422516 (422.5 KB)
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
```
### 如何在 Ubuntu 16.04 LTS 中临时添加辅助 IP 地址
正如本文开头所述，网络接口名称从 Ubuntu 15.10 就开始从 ‘ethX’ 更改为 ‘enXXXX’ (enp0s3)，所以，替换你的接口名称。
在执行此操作之前，先检查系统上的 IP 信息：
```
# ifconfig
或
# ip addr
enp0s3: flags=4163 mtu 1500
inet 192.168.56.201 netmask 255.255.255.0 broadcast 192.168.56.255
inet6 fe80::a00:27ff:fe97:132e prefixlen 64 scopeid 0x20
ether 08:00:27:97:13:2e txqueuelen 1000 (Ethernet)
RX packets 7 bytes 420 (420.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 294 bytes 24747 (24.7 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
enp0s8: flags=4163 mtu 1500
inet 10.0.3.15 netmask 255.255.255.0 broadcast 10.0.3.255
inet6 fe80::344b:6259:4dbe:eabb prefixlen 64 scopeid 0x20
ether 08:00:27:12:e8:c1 txqueuelen 1000 (Ethernet)
RX packets 1 bytes 590 (590.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 97 bytes 10209 (10.2 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73 mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10
loop txqueuelen 1000 (Local Loopback)
RX packets 325 bytes 24046 (24.0 KB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 325 bytes 24046 (24.0 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
```
如我所见，服务器主 IP 地址是 `192.168.56.201`，所以，我将下一个 IP `192.168.56.202` 作为辅助 IP，使用以下命令完成。
```
# ip addr add 192.168.56.202/24 broadcast 192.168.56.255 dev enp0s3
```
运行以下命令来检查是否已分配了新的 IP。当你重启机器时，它会消失。
```
# ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: enp0s3: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:97:13:2e brd ff:ff:ff:ff:ff:ff
inet 192.168.56.201/24 brd 192.168.56.255 scope global enp0s3
valid_lft forever preferred_lft forever
inet 192.168.56.202/24 brd 192.168.56.255 scope global secondary enp0s3
valid_lft forever preferred_lft forever
inet6 fe80::a00:27ff:fe97:132e/64 scope link
valid_lft forever preferred_lft forever
3: enp0s8: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:12:e8:c1 brd ff:ff:ff:ff:ff:ff
inet 10.0.3.15/24 brd 10.0.3.255 scope global dynamic enp0s8
valid_lft 86353sec preferred_lft 86353sec
inet6 fe80::344b:6259:4dbe:eabb/64 scope link
valid_lft forever preferred_lft forever
```
### 如何在 Ubuntu 16.04 LTS 中添加永久辅助 IP 地址
要在 Ubuntu 系统上添加永久辅助 IP 地址，只需编辑 `/etc/network/interfaces` 文件并添加所需 IP 的详细信息。
我们不应该在 `dns-nameservers` 行之后添加辅助 IP 地址，因为它不会起作用，应该以下面的格式添加 IP 详情。
此外，我们不需要添加子接口（我们之前在 Ubuntu 14.04 LTS 中的做法）：
```
# vi /etc/network/interfaces
# interfaces(5) file used by ifup(8) and ifdown(8)
auto lo
iface lo inet loopback
# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.56.201
netmask 255.255.255.0
iface enp0s3 inet static
address 192.168.56.202
netmask 255.255.255.0
gateway 192.168.56.1
network 192.168.56.0
broadcast 192.168.56.255
dns-nameservers 8.8.8.8 8.8.4.4
dns-search 2daygeek.local
```
保存并关闭文件，然后重启网络接口服务：
```
# systemctl restart networking
或
# ifdown enp0s3 && ifup enp0s3
```
运行以下命令来检查是否已经分配了新的 IP：
```
# ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: enp0s3: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:97:13:2e brd ff:ff:ff:ff:ff:ff
inet 192.168.56.201/24 brd 192.168.56.255 scope global enp0s3
valid_lft forever preferred_lft forever
inet 192.168.56.202/24 brd 192.168.56.255 scope global secondary enp0s3
valid_lft forever preferred_lft forever
inet6 fe80::a00:27ff:fe97:132e/64 scope link
valid_lft forever preferred_lft forever
3: enp0s8: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:12:e8:c1 brd ff:ff:ff:ff:ff:ff
inet 10.0.3.15/24 brd 10.0.3.255 scope global dynamic enp0s8
valid_lft 86353sec preferred_lft 86353sec
inet6 fe80::344b:6259:4dbe:eabb/64 scope link
valid_lft forever preferred_lft forever
```
让我来 ping 一下新 IP 地址：
```
# ping 192.168.56.202 -c 4
PING 192.168.56.202 (192.168.56.202) 56(84) bytes of data.
64 bytes from 192.168.56.202: icmp_seq=1 ttl=64 time=0.019 ms
64 bytes from 192.168.56.202: icmp_seq=2 ttl=64 time=0.087 ms
64 bytes from 192.168.56.202: icmp_seq=3 ttl=64 time=0.034 ms
64 bytes from 192.168.56.202: icmp_seq=4 ttl=64 time=0.042 ms
--- 192.168.56.202 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3068ms
rtt min/avg/max/mdev = 0.019/0.045/0.087/0.026 ms
```
---
via: <https://www.2daygeek.com/how-to-add-additional-ip-secondary-ip-in-ubuntu-debian-system/>
作者：[Prakash Subramanian](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
API Star：一个 Python 3 的 API 框架
|
Masnun
|
http://polyglot.ninja/api-star-python-3-api-framework/
|
为了在 Python 中快速构建 API，我主要依赖于 Flask。最近我遇到了一个名为 “API Star” 的基于 Python 3 的新 API 框架。
|
/data/attachment/album/201809/07/205327dvf31khzwmvzvevc.jpg.thumb.jpg
|
/data/attachment/album/201809/07/205327dvf31khzwmvzvevc.jpg
| true | false | true |
MjSeven
|
wxy
| false |
[
"API",
"Python"
] |
软件开发
|
{
"viewnum": 9617,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
为了在 Python 中快速构建 API，我主要依赖于 Flask。最近我遇到了一个名为 “API Star” 的基于 Python 3 的新 API 框架。
| 2018-09-07T20:54:16 | 2018-09-07T20:54:16 | 9,987 |
/article-9987-1.html
|
为了在 Python 中快速构建 API，我主要依赖于 [Flask](http://polyglot.ninja/rest-api-best-practices-python-flask-tutorial/)。最近我遇到了一个名为 “API Star” 的基于 Python 3 的新 API 框架。由于几个原因，我对它很感兴趣。首先，该框架包含 Python 新特点，如类型提示和 asyncio。而且它再进一步为开发人员提供了很棒的开发体验。我们很快就会讲到这些功能，但在我们开始之前，我首先要感谢 Tom Christie，感谢他为 Django REST Framework 和 API Star 所做的所有工作。
现在说回 API Star —— 我感觉这个框架很有成效。我可以选择基于 asyncio 编写异步代码，或者可以选择传统后端方式就像 WSGI 那样。它配备了一个命令行工具 —— `apistar` 来帮助我们更快地完成工作。它支持 Django ORM 和 SQLAlchemy，这是可选的。它有一个出色的类型系统，使我们能够定义输入和输出的约束，API Star 可以自动生成 API 的模式（包括文档），提供验证和序列化功能等等。虽然 API Star 专注于构建 API，但你也可以非常轻松地在其上构建 Web 应用程序。在我们自己构建一些东西之前，所有这些可能都没有意义的。
### 开始
我们将从安装 API Star 开始。为此实验创建一个虚拟环境是一个好主意。如果你不知道如何创建一个虚拟环境，不要担心，继续往下看。
```
pip install apistar
```
（译注：上面的命令是在 Python 3 虚拟环境下使用的）
如果你没有使用虚拟环境或者你的 Python 3 的 `pip` 名为 `pip3`，那么使用 `pip3 install apistar` 代替。
一旦我们安装了这个包，我们就应该可以使用 `apistar` 命令行工具了。我们可以用它创建一个新项目，让我们在当前目录中创建一个新项目。
```
apistar new .
```
现在我们应该创建两个文件：`app.py`，它包含主应用程序，然后是 `test.py`，它用于测试。让我们来看看 `app.py` 文件：
```
from apistar import Include, Route
from apistar.frameworks.wsgi import WSGIApp as App
from apistar.handlers import docs_urls, static_urls
def welcome(name=None):
if name is None:
return {'message': 'Welcome to API Star!'}
return {'message': 'Welcome to API Star, %s!' % name}
routes = [
Route('/', 'GET', welcome),
Include('/docs', docs_urls),
Include('/static', static_urls)
]
app = App(routes=routes)
if __name__ == '__main__':
app.main()
```
在我们深入研究代码之前，让我们运行应用程序并查看它是否正常工作。我们在浏览器中输入 `http://127.0.0.1:8080/`，我们将得到以下响应：
```
{"message": "Welcome to API Star!"}
```
如果我们输入：`http://127.0.0.1:8080/?name=masnun`
```
{"message": "Welcome to API Star, masnun!"}
```
同样的，输入 `http://127.0.0.1:8080/docs/`，我们将看到自动生成的 API 文档。
现在让我们来看看代码。我们有一个 `welcome` 函数，它接收一个名为 `name` 的参数，其默认值为 `None`。API Star 是一个智能的 API 框架。它将尝试在 url 路径或者查询字符串中找到 `name` 键并将其传递给我们的函数，它还基于其生成 API 文档。这真是太好了，不是吗？
然后，我们创建一个 `Route` 和 `Include` 实例的列表，并将列表传递给 `App` 实例。`Route` 对象用于定义用户自定义路由。顾名思义，`Include` 包含了在给定的路径下的其它 url 路径。
### 路由
路由很简单。当构造 `App` 实例时，我们需要传递一个列表作为 `routes` 参数，这个列表应该有我们刚才看到的 `Route` 或 `Include` 对象组成。对于 `Route`，我们传递一个 url 路径，http 方法和可调用的请求处理程序（函数或者其他）。对于 `Include` 实例，我们传递一个 url 路径和一个 `Routes` 实例列表。
#### 路径参数
我们可以在花括号内添加一个名称来声明 url 路径参数。例如 `/user/{user_id}` 定义了一个 url，其中 `user_id` 是路径参数，或者说是一个将被注入到处理函数（实际上是可调用的）中的变量。这有一个简单的例子：
```
from apistar import Route
from apistar.frameworks.wsgi import WSGIApp as App
def user_profile(user_id: int):
return {'message': 'Your profile id is: {}'.format(user_id)}
routes = [
Route('/user/{user_id}', 'GET', user_profile),
]
app = App(routes=routes)
if __name__ == '__main__':
app.main()
```
如果我们访问 `http://127.0.0.1:8080/user/23`，我们将得到以下响应：
```
{"message": "Your profile id is: 23"}
```
但如果我们尝试访问 `http://127.0.0.1:8080/user/some_string`，它将无法匹配。因为我们定义了 `user_profile` 函数，且为 `user_id` 参数添加了一个类型提示。如果它不是整数，则路径不匹配。但是如果我们继续删除类型提示，只使用 `user_profile(user_id)`，它将匹配此 url。这也展示了 API Star 的智能之处和利用类型和好处。
#### 包含/分组路由
有时候将某些 url 组合在一起是有意义的。假设我们有一个处理用户相关功能的 `user` 模块，将所有与用户相关的 url 分组在 `/user` 路径下可能会更好。例如 `/user/new`、`/user/1`、`/user/1/update` 等等。我们可以轻松地在单独的模块或包中创建我们的处理程序和路由，然后将它们包含在我们自己的路由中。
让我们创建一个名为 `user` 的新模块，文件名为 `user.py`。我们将以下代码放入这个文件：
```
from apistar import Route
def user_new():
return {"message": "Create a new user"}
def user_update(user_id: int):
return {"message": "Update user #{}".format(user_id)}
def user_profile(user_id: int):
return {"message": "User Profile for: {}".format(user_id)}
user_routes = [
Route("/new", "GET", user_new),
Route("/{user_id}/update", "GET", user_update),
Route("/{user_id}/profile", "GET", user_profile),
]
```
现在我们可以从 app 主文件中导入 `user_routes`，并像这样使用它：
```
from apistar import Include
from apistar.frameworks.wsgi import WSGIApp as App
from user import user_routes
routes = [
Include("/user", user_routes)
]
app = App(routes=routes)
if __name__ == '__main__':
app.main()
```
现在 `/user/new` 将委托给 `user_new` 函数。
### 访问查询字符串/查询参数
查询参数中传递的任何参数都可以直接注入到处理函数中。比如 url `/call?phone=1234`，处理函数可以定义一个 `phone` 参数，它将从查询字符串/查询参数中接收值。如果 url 查询字符串不包含 `phone` 的值，那么它将得到 `None`。我们还可以为参数设置一个默认值，如下所示：
```
def welcome(name=None):
if name is None:
return {'message': 'Welcome to API Star!'}
return {'message': 'Welcome to API Star, %s!' % name}
```
在上面的例子中，我们为 `name` 设置了一个默认值 `None`。
### 注入对象
通过给一个请求程序添加类型提示，我们可以将不同的对象注入到视图中。注入请求相关的对象有助于处理程序直接从内部访问它们。API Star 内置的 `http` 包中有几个内置对象。我们也可以使用它的类型系统来创建我们自己的自定义对象并将它们注入到我们的函数中。API Star 还根据指定的约束进行数据验证。
让我们定义自己的 `User` 类型，并将其注入到我们的请求处理程序中：
```
from apistar import Include, Route
from apistar.frameworks.wsgi import WSGIApp as App
from apistar import typesystem
class User(typesystem.Object):
properties = {
'name': typesystem.string(max_length=100),
'email': typesystem.string(max_length=100),
'age': typesystem.integer(maximum=100, minimum=18)
}
required = ["name", "age", "email"]
def new_user(user: User):
return user
routes = [
Route('/', 'POST', new_user),
]
app = App(routes=routes)
if __name__ == '__main__':
app.main()
```
现在如果我们发送这样的请求：
```
curl -X POST \
http://127.0.0.1:8080/ \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
-d '{"name": "masnun", "email": "masnun@gmail.com", "age": 12}'
```
猜猜发生了什么？我们得到一个错误，说年龄必须等于或大于 18。类型系允许我们进行智能数据验证。如果我们启用了 `docs` url，我们还将自动记录这些参数。
### 发送响应
如果你已经注意到，到目前为止，我们只可以传递一个字典，它将被转换为 JSON 并作为默认返回。但是，我们可以使用 `apistar` 中的 `Response` 类来设置状态码和其它任意响应头。这有一个简单的例子：
```
from apistar import Route, Response
from apistar.frameworks.wsgi import WSGIApp as App
def hello():
return Response(
content="Hello".encode("utf-8"),
status=200,
headers={"X-API-Framework": "API Star"},
content_type="text/plain"
)
routes = [
Route('/', 'GET', hello),
]
app = App(routes=routes)
if __name__ == '__main__':
app.main()
```
它应该返回纯文本响应和一个自定义标响应头。请注意，`content` 应该是字节，而不是字符串。这就是我编码它的原因。
### 继续
我刚刚介绍了 API Star 的一些特性，API Star 中还有许多非常酷的东西，我建议通过 [Github Readme](https://github.com/encode/apistar) 文件来了解这个优秀框架所提供的不同功能的更多信息。我还将尝试在未来几天内介绍关于 API Star 的更多简短的，集中的教程。
---
via: <http://polyglot.ninja/api-star-python-3-api-framework/>
作者：[MASNUN](http://polyglot.ninja/author/masnun/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何在 Linux 中安装 2048 游戏
|
Abhishek Prakash
|
https://itsfoss.com/2048-game/
|
流行的移动益智游戏 2048 也可以在 Ubuntu 和 Linux 发行版上玩。啊！你甚至可以在 Linux 终端上玩 2048。如果你的生产率因为这个让人上瘾的游戏下降，请不要怪我。
|
/data/attachment/album/201809/08/080621uoot78o1ehaa1dwt.jpg.thumb.jpg
|
/data/attachment/album/201809/08/080621uoot78o1ehaa1dwt.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"游戏",
"2048"
] |
分享
|
{
"viewnum": 6569,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
流行的移动益智游戏 2048 也可以在 Ubuntu 和 Linux 发行版上玩。啊！你甚至可以在 Linux 终端上玩 2048。如果你的生产率因为这个让人上瘾的游戏下降，请不要怪我。
| 2018-09-08T08:06:00 | 2018-09-08T08:06:00 | 9,988 |
/article-9988-1.html
|
>
> 流行的移动益智游戏 2048 也可以在 Ubuntu 和 Linux 发行版上玩。啊！你甚至可以在 Linux 终端上玩 2048。如果你的生产率因为这个让人上瘾的游戏下降，请不要怪我。
>
>
>
早在 2014 年，2048 就是 iOS 和 Android 上最受欢迎的游戏之一。这款令人上瘾的游戏非常受欢迎，它在 Linux 上有[浏览器版](http://gabrielecirulli.github.io/2048/)、桌面版和终端版。
通过向上和向下，向左和向右移动滑块来玩这个小游戏。这个益智游戏的目的是通过组合匹配的滑块到数字 2048。因此 2+2 变成 4，4+4 变成 8，依此类推。这可能听起来简单而无聊，但相信我是一个令人上瘾的游戏。
### 在 Linux 中玩 2048 [GUI]
在 Ubuntu 和其他 Linux 中有些 2048 游戏。你可以在软件中心中搜索它，你可以在那里找到一些。
有一个[基于 Qt](https://www.qt.io/) 的 2048 游戏，你可以在 Ubuntu 和其他基于 Debian 和 Ubuntu 的 Linux 发行版上安装。你可以使用以下命令安装它：
```
sudo apt install 2048-qt
```
安装完成后，你可以在菜单中找到该游戏并启动它。你可以使用箭头键移动数字。你的最高分也会保存。
### 在 Linux 终端玩 2048
2048 的流行将它带到了终端。如果这让你感到惊讶，你应该知道 Linux 中有很多[很棒的终端游戏](https://itsfoss.com/best-command-line-games-linux/)，而 2048 肯定就是其中之一。
现在，有几种方法可以在 Linux 终端中玩 2048。我在这里提其中两个。
#### 1、term2048 Snap 程序
有一个名为 [term2048](https://snapcraft.io/term2048) 的 [snap 程序](https://itsfoss.com/use-snap-packages-ubuntu-16-04/)可以安装在任何[支持 Snap 的 Linux 发行版](https://itsfoss.com/install-snap-linux/)中。
如果你启用了 Snap，只需使用此命令安装 term2048：
```
sudo snap install term2048
```
Ubuntu 用户也可以在软件中心找到这个游戏并从那里安装它。
安装后，你可以使用命令 term2048 来运行游戏。它看起来像这样：
你可以使用箭头键移动。
#### 2、2048 游戏的 Bash 脚本
这个游戏实际上是一个 shell 脚本，你可以在任何 Linux 终端上运行。从 Github 下载游戏/脚本：
* [下载 Bash2048](https://github.com/mydzor/bash2048)
解压下载的文件。进入解压后的目录，你将看到名为 2048.sh 的 shell 脚本。只需运行 shell 脚本。游戏将立即开始。你可以使用箭头键移动滑块。
### 你在Linux上玩什么游戏？
如果你喜欢在 Linux 终端上玩游戏，你也应该尝试 [Linux 终端中的经典 Snake 游戏](https://itsfoss.com/nsnake-play-classic-snake-game-linux-terminal/ "nSnake: Play The Classic Snake Game In Linux Terminal")。
你经常在 Linux 中玩哪些游戏？你也在终端中玩游戏吗？如果是的话，哪个是你最喜欢的终端游戏？
---
via: <https://itsfoss.com/2048-game/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 VS Code 进行 Python 编程
|
Clément Verna
|
https://fedoramagazine.org/vscode-python-howto/
|
安装启用 Python 扩展后，VS Code 可以配置成理想的 Python 开发工作环境。本文将介绍一些有用的 VS Code 扩展，并配置它们以充分提高 Python 开发效率。
|
/data/attachment/album/201809/08/083157eicjayyyy1a85q85.jpg.thumb.jpg
|
/data/attachment/album/201809/08/083157eicjayyyy1a85q85.jpg
| true | false | true |
lujun9972
|
idea2act
|
wxy
| false |
[
"Python",
"VSCode"
] |
软件开发
|
{
"viewnum": 13528,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
安装启用 Python 扩展后，VS Code 可以配置成理想的 Python 开发工作环境。本文将介绍一些有用的 VS Code 扩展，并配置它们以充分提高 Python 开发效率。
| 2018-09-08T08:31:00 | 2018-09-08T08:31:00 | 9,989 |
/article-9989-1.html
|
Visual Studio Code，简称 VS Code，是一个开源的文本编辑器，包含用于构建和调试应用程序的工具。安装启用 Python 扩展后，VS Code 可以配置成理想的 Python 开发工作环境。本文将介绍一些有用的 VS Code 扩展，并配置它们以充分提高 Python 开发效率。
如果你的计算机上还没有安装 VS Code，可以参考文章 [在 Fedora 上使用 VS Code](https://fedoramagazine.org/using-visual-studio-code-fedora/) 来安装。
### 在 VS Code 中安装 Python 扩展
首先，为了更方便地在 VS Code 中进行 Python 开发，需要从 VS Code 扩展商店中安装 Python 扩展。
Python 扩展安装完成后，就可以开始配置 Python 扩展了。
VS Code 通过两个 JSON 文件管理设置:
* 一个文件用于 VS Code 的全局设置，作用于所有的项目
* 另一个文件用于特殊设置，作用于单独项目
可以用快捷键 `Ctrl+,` （逗号）打开全局设置，也可以通过 **文件 -> 首选项 -> 设置** 来打开。
#### 设置 Python 路径
您可以在全局设置中配置 `python.pythonPath` 使 VS Code 自动为每个项目选择最适合的 Python 解释器。
```
// 将设置放在此处以覆盖默认设置和用户设置。
// Path to Python, you can use a custom version of Python by modifying this setting to include the full path.
{
"python.pythonPath":"${workspaceRoot}/.venv/bin/python",
}
```
这样，VS Code 将使用虚拟环境目录 `.venv` 下项目根目录中的 Python 解释器。
#### 使用环境变量
默认情况下，VS Code 使用项目根目录下的 `.env` 文件中定义的环境变量。 这对于设置环境变量很有用，如：
```
PYTHONWARNINGS="once"
```
可使程序在运行时显示警告。
可以通过设置 `python.envFile` 来加载其他的默认环境变量文件：
```
// Absolute path to a file containing environment variable definitions.
"python.envFile": "${workspaceFolder}/.env",
```
### 代码分析
Python 扩展还支持不同的代码分析工具（pep8、flake8、pylint）。要启用你喜欢的或者正在进行的项目所使用的分析工具，只需要进行一些简单的配置。
扩展默认情况下使用 pylint 进行代码分析。你可以这样配置以使用 flake8 进行分析：
```
"python.linting.pylintEnabled": false,
"python.linting.flake8Path": "${workspaceRoot}/.venv/bin/flake8",
"python.linting.flake8Enabled": true,
"python.linting.flake8Args": ["--max-line-length=90"],
```
启用代码分析后，分析器会在不符合要求的位置加上波浪线，鼠标置于该位置，将弹窗提示其原因。注意，项目的虚拟环境中需要安装有 flake8，此示例方能有效。
### 格式化代码
可以配置 VS Code 使其自动格式化代码。目前支持 autopep8、black 和 yapf。下面的设置将启用 “black” 模式。
```
// Provider for formatting. Possible options include 'autopep8', 'black', and 'yapf'.
"python.formatting.provider": "black",
"python.formatting.blackPath": "${workspaceRoot}/.venv/bin/black"
"python.formatting.blackArgs": ["--line-length=90"],
"editor.formatOnSave": true,
```
如果不需要编辑器在保存时自动格式化代码，可以将 `editor.formatOnSave` 设置为 `false` 并手动使用快捷键 `Ctrl + Shift + I` 格式化当前文档中的代码。 注意，项目的虚拟环境中需要安装有 black，此示例方能有效。
### 运行任务
VS Code 的一个重要特点是它可以运行任务。需要运行的任务保存在项目根目录中的 JSON 文件中。
#### 运行 flask 开发服务
这个例子将创建一个任务来运行 Flask 开发服务器。 使用一个可以运行外部命令的基本模板来创建新的工程：
编辑如下所示的 `tasks.json` 文件，创建新任务来运行 Flask 开发服务：
```
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
{
"label": "Run Debug Server",
"type": "shell",
"command": "${workspaceRoot}/.venv/bin/flask run -h 0.0.0.0 -p 5000",
"group": {
"kind": "build",
"isDefault": true
}
}
]
}
```
Flask 开发服务使用环境变量来获取应用程序的入口点。 如 **使用环境变量** 一节所说，可以在 `.env` 文件中声明这些变量：
```
FLASK_APP=wsgi.py
FLASK_DEBUG=True
```
这样就可以使用快捷键 `Ctrl + Shift + B` 来执行任务了。
### 单元测试
VS Code 还支持单元测试框架 pytest、unittest 和 nosetest。启用测试框架后，可以在 VS Code 中单独运行搜索到的单元测试，通过测试套件运行测试或者运行所有的测试。
例如，可以这样启用 pytest 测试框架：
```
"python.unitTest.pyTestEnabled": true,
"python.unitTest.pyTestPath": "${workspaceRoot}/.venv/bin/pytest",
```
注意，项目的虚拟环境中需要安装有 pytest，此示例方能有效。
---
via: <https://fedoramagazine.org/vscode-python-howto/>
作者：[Clément Verna](https://fedoramagazine.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[idea2act](https://github.com/idea2act) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何重置 MySQL 或 MariaDB 的 Root 密码
|
Sk
|
https://www.ostechnix.com/how-to-reset-mysql-or-mariadb-root-password/
|
几个月前，我在Ubuntu 18.04 上安装了 LAMP。今天，我尝试以 root 用户身份登录数据库，但我完全忘记了密码。经过一阵 Google 搜索并浏览一些文章后，我成功重置了密码。
|
/data/attachment/album/201809/08/084810x9tfxf37crzza9rl.png.thumb.jpg
|
/data/attachment/album/201809/08/084810x9tfxf37crzza9rl.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"MySQL",
"密码"
] |
技术
|
{
"viewnum": 6324,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
几个月前，我在Ubuntu 18.04 上安装了 LAMP。今天，我尝试以 root 用户身份登录数据库，但我完全忘记了密码。经过一阵 Google 搜索并浏览一些文章后，我成功重置了密码。
| 2018-09-08T08:48:08 | 2018-09-08T08:48:08 | 9,990 |
/article-9990-1.html
|
几个月前，我在[Ubuntu 18.04 上安装了 LAMP](https://www.ostechnix.com/install-apache-mariadb-php-lamp-stack-ubuntu-16-04/)。今天，我尝试以 root 用户身份登录数据库，但我完全忘记了密码。经过一阵 Google 搜索并浏览一些文章后，我成功重置了密码。对于那些想知道如何做到这一点的人，这个简短的教程解释了如何在类 Unix 操作系统中重置 MySQL 或 MariaDB Root 密码。
### 重置 MySQL 或 MariaDB Root 密码
首先，停止数据库。
如果你使用 MySQL，请输入以下命令并下按回车键。
```
$ sudo systemctl stop mysql
```
对于 MariaDB：
```
$ sudo systemctl stop mariadb
```
接下来，使用以下命令在没有权限检查的情况下重新启动数据库：
```
$ sudo mysqld_safe --skip-grant-tables &
```
这里， `--skip-grant-tables` 选项让你在没有密码和所有权限的情况下进行连接。如果使用此选项启动服务器，它还会启用 `--skip-networking` 选项，这用于防止其他客户端连接到数据库服务器。并且，`&` 符号用于在后台运行命令，因此你可以在以下步骤中输入其他命令。请注意，上述命令很危险，并且你的数据库会变得不安全。你应该只在短时间内运行此命令以重置密码。
接下来，以 root 用户身份登录 MySQL/MariaDB 服务器：
```
$ mysql
```
在 **mysql >** 或 **MariaDB [(none)] >** 提示符下，运行以下命令重置 root 用户密码：
```
UPDATE mysql.user SET Password=PASSWORD('NEW-PASSWORD') WHERE User='root';
```
使用你自己的密码替换上述命令中的 **NEW-PASSWORD**。
然后，输入以下命令退出 mysql 控制台。
```
FLUSH PRIVILEGES;
exit
```
最后，关闭之前使用 `--skip-grant-tables` 选项运行的数据库。为此，运行：
```
$ sudo mysqladmin -u root -p shutdown
```
系统将要求你输入在上一步中设置的 MySQL/MariaDB 用户密码。
现在，使用以下命令正常启动 MySQL/MariaDB 服务：
```
$ sudo systemctl start mysql
```
对于 MariaDB：
```
$ sudo systemctl start mariadb
```
使用以下命令验证密码是否确实已更改：
```
$ mysql -u root -p
```
今天就是这些了。还有更多好东西。敬请期待！
干杯!
---
via: <https://www.ostechnix.com/how-to-reset-mysql-or-mariadb-root-password/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
初学者指南：在 Ubuntu Linux 上安装和使用 Git 和 GitHub
|
Akshay Pai
|
https://www.howtoforge.com/tutorial/install-git-and-github-on-ubuntu/
|
这篇向导是对于安装和使用 GitHub 的的一个快速说明，本文还将涉及诸如创建本地仓库，如何链接这个本地仓库到包含你的项目的远程仓库（这样每个人都能看到你的项目了），以及如何提交改变并最终推送所有的本地内容到 Github。
|
/data/attachment/album/201809/08/220308ojzimmzqajtm7t3b.png.thumb.jpg
|
/data/attachment/album/201809/08/220308ojzimmzqajtm7t3b.png
| true | false | true |
lujun9972
|
DavidChenLiang
|
wxy
| false |
[
"GitHub",
"Git"
] |
技术
|
{
"viewnum": 5870,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这篇向导是对于安装和使用 GitHub 的的一个快速说明，本文还将涉及诸如创建本地仓库，如何链接这个本地仓库到包含你的项目的远程仓库（这样每个人都能看到你的项目了），以及如何提交改变并最终推送所有的本地内容到 Github。
| 2018-09-08T22:03:24 | 2018-09-08T22:03:24 | 9,991 |
/article-9991-1.html
|
Github 是一个存放着世界上最棒的一些软件项目的宝藏，这些软件项目由全世界的开发者无私贡献。这个看似简单，实则非常强大的平台因为大大帮助了那些对开发大规模软件感兴趣的开发者而被开源社区所称道。
这篇向导是对于安装和使用 GitHub 的的一个快速说明，本文还将涉及诸如创建本地仓库，如何链接这个本地仓库到包含你的项目的远程仓库（这样每个人都能看到你的项目了），以及如何提交改变并最终推送所有的本地内容到 Github。
请注意这篇向导假设你对 Git 术语有基本的了解，如推送、拉取请求（PR）、提交、仓库等等。并且希望你在 GitHub 上已注册成功并记下了你的 GitHub 用户名，那么我们这就进入正题吧：
### 1、在 Linux 上安装 Git
下载并安装 Git：
```
sudo apt-get install git
```
上面的命令适用于 Ubuntu 并且应该在所有最新版的 Ubuntu 上都能工作，它们在 Ubuntu 16.04 和 Ubuntu 18.04 LTS （Bionic Beaver）上都测试过，在将来的版本上应该也能工作。
### 2、配置 GitHub
一旦安装完成，接下去就是配置 GitHub 用户的详细配置信息。请使用下面的两条命令，并确保用你自己的 GitHub 用户名替换 `user_name`，用你创建 GitHub 账户的电子邮件替换 `email_id`。
```
git config --global user.name "user_name"
git config --global user.email "email_id"
```
下面的图片显示的例子是如何用我的 GitHub 用户名：“akshaypai” 和我的邮件地址 “[abc123@gmail.com](mailto:abc123@gmail.com)” 来配置上面的命令。
[](https://www.howtoforge.com/images/ubuntu_github_getting_started/big/config.png)
### 3、创建本地仓库
在你的系统上创建一个目录。它将会被作为本地仓库使用，稍后它会被推送到 GitHub 的远程仓库。请使用如下命令：
```
git init Mytest
```
如果目录被成功创建，你会看到如下信息：
```
Initialized empty Git repository in /home/akshay/Mytest/.git/
```
这行信息可能随你的系统不同而变化。
这里，`Mytest` 是创建的目录，而 `init` 将其转化为一个 GitHub 仓库。将当前目录改为这个新创建的目录。
```
cd Mytest
```
### 4、新建一个 README 文件来描述仓库
现在创建一个 `README` 文件并输入一些文本，如 “this is git setup on linux”。README 文件一般用于描述这个仓库用来放置什么内容或这个项目是关于什么的。例如：
```
gedit README
```
你可以使用任何文本编辑器。我喜欢使用 gedit。`README` 文件的内容可以为：
```
This is a git repo
```
### 5、将仓库里的文件加入一个索引
这是很重要的一步。这里我们会将所有需要推送到 GitHub 的内容都加入一个索引。这些内容可能包括你第一次加入仓库的文本文件或者应用程序，也有可能是对已存在文件的一些编辑（文件的一个更新版本）。
既然我们已经有了 `README` 文件，那么让我们创建一个别的文件吧，如一个简单的 C 程序，我们叫它 `sample.c`。文件内容是:
```
#include<stdio.h>
int main()
{
printf("hello world");
return 0;
}
```
现在我们有两个文件了。`README` 和 `sample.c`。
用下面的命令将它们加入索引：
```
git add README
git add smaple.c
```
请注意 `git add` 命令能将任意数量的文件和目录加入到索引。这里，当我说 “索引” 的时候，我是指一个有一定空间的缓冲区，这个缓冲区存储了所有已经被加入到 Git 仓库的文件或目录。
### 6、将所作的改动加入索引
所有的文件都加好以后，你就可以提交了。这意味着你已经确定了最终的文件改动（或增加），现在它们已经准备好被上传到我们自己的仓库了。请使用命令：
```
git commit -m "some_message"
```
“some\_message” 在上面的命令里可以是一些简单的信息如“我的第一次提交”或者“ 编辑了readme 文件”，等等。
### 7、在 GitHub 上创建一个仓库
在 GitHub 上创建一个仓库。请注意仓库的名字必须和你本地创建的仓库的名字严格一致。在这个例子里是 “Mytest”。请首先登录你的 [GitHub](https://github.com) 账户 。点击页面右上角的 “+” 符号，并选择“create nw repository”。如下图所示填入详细信息，点击 “create repository”。
[](https://www.howtoforge.com/images/ubuntu_github_getting_started/big/details.png)
一旦创建完成，我们就能将本地的仓库推送到 GitHub 你名下的仓库，用下列命令连接 GitHub 上的仓库：
>
> 请注意：请确保在运行下列命令前替换了路径中的 “user\_name” 和 “Mytest” 为你的 GitHub 用户名和目录名！
>
>
>
```
git remote add origin https://github.com/user\_name/Mytest.git>
```
### 8、将本地仓库里的文件推送到 GitHub 仓库
最后一步是用下列的命令将本地仓库的内容推送到远程仓库（GitHub）：
```
git push origin master
```
当提示登录名和密码时键入登录名和密码。
下面的图片显示了步骤5到步骤8的流程
[](https://www.howtoforge.com/images/ubuntu_github_getting_started/big/steps.png)
上述将 Mytest 目录里的所有内容（文件）推送到了 GitHub。对于以后的项目或者创建新的仓库，你可以直接从步骤 3 开始。最后，如果你登录你的 GitHub 账户并点击你的 Mytest 仓库，你会看到这两个文件：`README` 和 `sample.c` 已经被上传并像如下图片显示：
[](https://www.howtoforge.com/images/ubuntu_github_getting_started/big/final.png)
---
via: <https://www.howtoforge.com/tutorial/install-git-and-github-on-ubuntu/>
作者：[Akshay Pai](https://www.howtoforge.com/tutorial/installing-tensorflow-neural-network-software-for-cpu-and-gpu-on-ubuntu-16-04/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[DavidChenLiang](https://github.com/DavidChenLiang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
介绍 Linux 中的管道和命名管道
|
Archit Modi
|
https://opensource.com/article/18/8/introduction-pipes-linux
|
要在命令间移动数据？使用管道可使此过程便捷。
|
/data/attachment/album/201809/08/224215dsqy20owo20meqql.jpg.thumb.jpg
|
/data/attachment/album/201809/08/224215dsqy20owo20meqql.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"管道"
] |
技术
|
{
"viewnum": 19175,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
要在命令间移动数据？使用管道可使此过程便捷。
| 2018-09-08T22:42:29 | 2018-09-08T22:42:29 | 9,992 |
/article-9992-1.html
|
>
> 要在命令间移动数据？使用管道可使此过程便捷。
>
>
>
在 Linux 中，`pipe` 能让你将一个命令的输出发送给另一个命令。管道，如它的名称那样，能重定向一个进程的标准输出、输入和错误到另一个进程，以便于进一步处理。
“管道”（或称“未命名管道”）命令的语法是在两个命令之间加上 `|` 字符：
```
Command-1 | Command-2 | ...| Command-N
```
这里，该管道不能通过另一个会话访问；它被临时创建用于接收 `Command-1` 的执行并重定向标准输出。它在成功执行之后删除。
在上面的示例中，`contents.txt` 包含特定目录中所有文件的列表 —— 具体来说，就是 `ls -al` 命令的输出。我们首先通过管道（如图所示）使用 “file” 关键字从 `contents.txt` 中 `grep` 文件名，因此 `cat` 命令的输出作为 `grep` 命令的输入提供。接下来，我们添加管道来执行 `awk` 命令，该命令显示 `grep` 命令的过滤输出中的第 9 列。我们还可以使用 `wc -l` 命令计算 `contents.txt` 中的行数。
只要系统启动并运行或直到它被删除，命名管道就可以持续使用。它是一个遵循 [FIFO](https://en.wikipedia.org/wiki/FIFO_(computing_and_electronics))（先进先出）机制的特殊文件。它可以像普通文件一样使用。也就是，你可以写入，从中读取，然后打开或关闭它。要创建命名管道，命令为：
```
mkfifo <pipe-name>
```
这将创建一个命名管道文件，它甚至可以在多个 shell 会话中使用。
创建 FIFO 命名管道的另一种方法是使用此命令：
```
mknod p <pipe-name>
```
要重定向任何命令的标准输出到其它命令，请使用 `>` 符号。要重定向任何命令的标准输入，请使用 `<` 符号。
如上所示，`ls -al` 命令的输出被重定向到 `contents.txt` 并插入到文件中。类似地，`tail` 命令的输入通过 `<` 符号从 `contents.txt` 读取。
这里，我们创建了一个命名管道 `my-named-pipe`，并将 `ls -al` 命令的输出重定向到命名管道。我们可以打开一个新的 shell 会话并 `cat` 命名管道的内容，如前所述，它显示了 `ls -al` 命令的输出。请注意，命名管道的大小为零，并有一个标志 “p”。
因此，下次你在 Linux 终端上使用命令并在命令之间移动数据时，希望管道使这个过程快速简便。
---
via: <https://opensource.com/article/18/8/introduction-pipes-linux>
作者：[Archit Modi](https://opensource.com/users/architmodi) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何将 WordPress 博客发布到静态 GitLab Pages 上
|
Christopher Aedo
|
https://opensource.com/article/18/8/publish-wordpress-static-gitlab-pages-site
|
通过 GitLab 或 GitHub Pages 来提供一个 WordPress 镜像站点, 从而最小化安全问题。
|
/data/attachment/album/201809/08/230644mnr3ja90xijz60jj.png.thumb.jpg
|
/data/attachment/album/201809/08/230644mnr3ja90xijz60jj.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"GitHub",
"GitLab"
] |
技术
|
{
"viewnum": 6235,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过 GitLab 或 GitHub Pages 来提供一个 WordPress 镜像站点, 从而最小化安全问题。
| 2018-09-08T23:05:00 | 2018-09-08T23:05:00 | 9,993 |
/article-9993-1.html
|
>
> 通过 GitLab 或 GitHub Pages 来提供一个 WordPress 镜像站点, 从而最小化安全问题。
>
>
>
很久以前，我为一个家庭成员建立了一个 WordPress 博客。如今有很多选择，但是当时如果你需要一个带有所见即所得的编辑器的基于 Web 的 CMS，那么就没什么像样的的选择了。而一切运行良好的不幸的副作用是随着时间的推移该博客产生了很多内容。这意味着我要经常更新 WordPress 以防止不断出现的漏洞。
因此，当我决定劝说家人切换到 [Hugo](https://gohugo.io/) 会相对容易，然后可以在 [GitLab](https://gitlab.com/) 上托管博客。但是尝试提取所有内容并将其转换为 [Markdown](https://en.wikipedia.org/wiki/Markdown) 变成了一个巨大的麻烦。有自动脚本完成了 95% 的工作，但并不完美。手动更新所有帖子不是我想做的事情，所以最终，我放弃了试图移动博客。
最近，我又开始考虑这个问题，并意识到有一个我没有考虑过的解决方案：我可以继续维护 WordPress 服务器，但将其设置为发布静态镜像，并使用 [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/)（或 [GitHub Pages](https://pages.github.com/) ，如果你喜欢的话）提供服务。这能让我自动化 [Let’s Encrypt](https://letsencrypt.org/) 证书续订并消除与托管 WordPress 站点相关的安全问题。然而，这意味着评论将无法使用，但在这种情况下感觉就像是一个小损失，因为博客没有收到很多评论。
这是我提出的解决方案，到目前为止似乎运作良好：
* 托管 WordPress 站点中的 URL 没有链接到或来自其他任何地方，以减少它被利用的几率。在此例中，我们将使用 <http://private.localconspiracy.com>（即使此站点实际上是使用 Pelican 构建的）。
* 将公共 URL <https://www.localconspiracy.com> [托管到 GitLab Pages 上](https://about.gitlab.com/2016/04/07/gitlab-pages-setup/)。
* 添加 [cron 任务](https://en.wikipedia.org/wiki/Cron)，确定两个 URL 之间的最后构建日期何时不同。如果构建日期不同，则镜像 WordPress 版本。
* 使用 `wget` 镜像后，将所有链接从“私有”更新成“公共”。
* 运行 `git push` 来发布新内容。
这是我使用的两个脚本：
`check-diff.sh` （cron 每 15 分钟调用一次）：
```
#!/bin/bash
ORIGINDATE="$(curl -v --silent http://private.localconspiracy.com/feed/ 2>&1|grep lastBuildDate)"
PUBDATE="$(curl -v --silent https://www.localconspiracy.com/feed/ 2>&1|grep lastBuildDate)"
if [ "$ORIGINDATE" != "$PUBDATE" ]
then
/home/doc/repos/localconspiracy/mirror.sh
fi
```
`mirror.sh`：
```
#!/bin/sh
cd /home/doc/repos/localconspiracy
wget \
--mirror \
--convert-links \
--adjust-extension \
--page-requisites \
--retry-connrefused \
--exclude-directories=comments \
--execute robots=off \
http://private.localconspiracy.com
git rm -rf public/*
mv private.localconspiracy.com/* public/.
rmdir private.localconspiracy.com
find ./public/ -type f -exec sed -i -e 's|http://private.localconspiracy|https://www.localconspiracy|g' {} \;
find ./public/ -type f -exec sed -i -e 's|http://www.localconspiracy|https://www.localconspiracy|g' {} \;
git add public/*
git commit -m "new snapshot"
git push origin master
```
就是这些了！现在，当博客发生变化时，在 15 分钟内将网站镜像到静态版本并推送到仓库，这将在 GitLab Pages 中反映出来。
如果你想[在本地运行 WordPress](https://codex.wordpress.org/Installing_WordPress_Locally_on_Your_Mac_With_MAMP)，这个概念可以进一步扩展。在这种情况下，你不需要服务器来托管你的 WordPress 博客。你可以在本机运行它。在这种情况下，你的博客不可能被攻击利用。只要你可以在本地运行 `wget`，就可以使用上面的方法在 GitLab Pages 上托管 WordPress 站点。
*这篇文章最初发表于 [Local Conspiracy](https://localconspiracy.com/2018/08/wp-on-gitlab.html)。允许转载。*
---
via: <https://opensource.com/article/18/8/publish-wordpress-static-gitlab-pages-site>
作者：[Christopher Aedo](https://opensource.com/users/docaedo) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何从 Linux 命令行安装软件
|
Patrick H.mullins
|
https://opensource.com/article/18/8/how-install-software-linux-command-line
|
学习一种不同的包管理器和怎么使用它。
|
/data/attachment/album/201809/09/100614zfa28iic15wcbzuc.png.thumb.jpg
|
/data/attachment/album/201809/09/100614zfa28iic15wcbzuc.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"安装",
"软件",
"包管理器"
] |
技术
|
{
"viewnum": 39077,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习一种不同的包管理器和怎么使用它。
| 2018-09-09T10:06:09 | 2018-09-09T10:06:09 | 9,994 |
/article-9994-1.html
|
>
> 学习一种不同的包管理器和怎么使用它。
>
>
>
如果你在一直在使用 Linux，你很快就会发现做同样的事情有很多不同的方法。这包括通过命令行在 Linux 上安装应用。我已经是大约 25 年的 Linux 用户，我一次又一次地回到命令行来安装我的应用。
从命令行安装应用程序最常用的方法是使用称为包管理器通过软件库（存储软件的地方）安装。所有 Linux 应用都作为软件包分发，这些软件包只不过是与软件包管理系统相关的文件。每个 Linux 发行版都附带一个包管理系统，但它们并不完全相同。
### 什么是包管理系统？
包管理系统由一组工具和文件格式组成，它们一起用于安装、更新和卸载 Linux 应用。两种最常见的包管理系统来自 Red Hat 和 Debian。 Red Hat、CentOS 和 Fedora 都使用 `rpm` 系统（.rpm 文件），而 Debian、Ubuntu、Mint 和 Ubuntu 都使用 `dpkg`（.deb 文件）。Gentoo Linux 使用名为 Portage 的系统，Arch Linux 只使用 tarball（.tar 文件）。这些系统之间的主要区别在于它们如何安装和维护应用。
你可能想知道 `.rpm`、`.deb` 或 `.tar` 文件中的内容。你可能会惊讶地发现，所有这些都只是普通的老式归档文件（如 `.zip`），其中包含应用的代码，如何安装它的说明，依赖项（它可能依赖的其他应用），以及配置文件的位置。读取和执行所有这些指令的软件称为包管理器。
### Debian、Ubuntu、Mint 等
Debian、Ubuntu、Mint 和其它基于 Debian 的发行版都使用 `.deb` 文件和 `dpkg` 包管理系统。有两种方法可以通过此系统安装应用。你可以使用 `apt` 程序从仓库进行安装，也可以使用 `dpkg` 程序从 `.deb` 文件安装应用。我们来看看如何做到这两点。
使用 `apt` 安装应用非常简单：
```
$ sudo apt install app_name
```
通过 `apt` 卸载应用也非常简单：
```
$ sudo apt remove app_name
```
要升级已安装的应用，首先需要更新应用仓库：
```
$ sudo apt update
```
完成后，你可以使用以下命令更新任何程序：
```
$ sudo apt upgrade
```
如果你只想更新一个应用，该怎么办？没问题。
```
$ sudo apt update app_name
```
最后，假设你要安装的应用不存在于 Debian 仓库中，但有 `.deb` 下载。
```
$ sudo dpkg -i app_name.deb
```
### Red Hat、CentOS 和 Fedora
默认情况下，Red Hat 使用多个包管理系统。这些系统在使用自己的命令时，互相仍然非常相似，而且与 Debian 中使用的也相似。例如，我们可以使用 `yum` 或 `dnf` 管理器来安装应用。
```
$ sudo yum install app_name
$ sudo dnf install app_name
```
`.rpm` 格式的应用也可以使用 `rpm` 命令安装。
```
$ sudo rpm -i app_name.rpm
```
删除不需要的应用同样容易。
```
$ sudo yum remove app_name
$ sudo dnf remove app_name
```
更新应用同样容易。
```
$ yum update
$ sudo dnf upgrade --refresh
```
如你所见，从命令行安装、卸载和更新 Linux 应用并不难。事实上，一旦你习惯它，你会发现它比使用基于桌面 GUI 的管理工具更快！
有关从命令行安装应用程序的更多信息，请访问 Debian [Apt wiki](https://wiki.debian.org/Apt)、[Yum 速查表](https://access.redhat.com/articles/yum-cheat-sheet) 和 [DNF wiki](https://fedoraproject.org/wiki/DNF?rd=Dnf)。
---
via: <https://opensource.com/article/18/8/how-install-software-linux-command-line>
作者：[Patrick H.Mullins](https://opensource.com/users/pmullins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
10 个在 Linux 上也有的流行的 Windows 程序
|
Martins D. Okoi
|
https://www.fossmint.com/install-popular-windows-apps-on-linux/
|
许多仅在 Windows 和/或 Mac上 有的程序可在 Linux 平台上使用了，而且不用麻烦。向 Snap 和 Flatpak 技术致敬，这些技术已经为 Linux 用户带来了许多“受限制”的程序。
|
/data/attachment/album/201809/09/164724d9zpfsxq5pep01f2.png.thumb.jpg
|
/data/attachment/album/201809/09/164724d9zpfsxq5pep01f2.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Windows",
"应用"
] |
分享
|
{
"viewnum": 6426,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
许多仅在 Windows 和/或 Mac上 有的程序可在 Linux 平台上使用了，而且不用麻烦。向 Snap 和 Flatpak 技术致敬，这些技术已经为 Linux 用户带来了许多“受限制”的程序。
| 2018-09-09T16:47:23 | 2018-09-09T16:47:23 | 9,995 |
/article-9995-1.html
|
回顾过去，2018 年是 Linux 社区的好年景。许多仅在 Windows 和/或 Mac上 有的程序可在 Linux 平台上使用了，而且不用麻烦。向 [Snap](https://www.fossmint.com/what-are-ubuntu-snaps-and-how-are-they-important/) 和 [Flatpak](https://www.fossmint.com/install-flatpak-in-linux/) 技术致敬，这些技术已经为 Linux 用户带来了许多“受限制”的程序。
**另请阅读**：[很酷的 Linux 程序和工具大全](https://www.fossmint.com/awesome-linux-software/)
今天，我们为你提供了一个有名的 Windows 程序列表，你不需要寻找它们的替代品，因为它们已经在 Linux 上可用。
### 1、Skype
它可以说是世界上最受欢迎的 VoIP 程序，**Skype** 提供出色的视频和语音通话质量，以及其他功能，如拨打本地和国际电话、固定电话、即时消息、表情符号等功能。
```
$ sudo snap install skype --classic
```
### 2、Spotify
**Spotify** 是最流行的音乐流媒体平台，在很长一段时间里，Linux 用户需要使用脚本和一些手段才能在他们的机器上设置该程序，感谢 snap，安装和使用 Spotify 就像点击一个按钮那样简单。
```
$ sudo snap install spotify
```
### 3、Minecraft
**Minecraft** 被证明是一款年度好游戏。更酷的是，它持续地得到维护。如果你不了解 Minecraft，它是一款冒险游戏，它可以让你在一个无限无边的虚拟世界中使用积木创建任何你想创建的虚拟事物。
```
$ sudo snap install minecraft
```
### 4、JetBrains Dev Suite
**JetBrains** 以其高级的开发 IDE 套件而闻名，他们这个最受欢迎的程序声称可在 Linux 上使用而不会有任何麻烦。
#### 安装 IDEA Community – Java IDE
```
$ sudo snap install intellij-idea-community --classic
```
#### 安装 PyCharm EDU – Python IDE
```
$ sudo snap install pycharm-educational --classic
```
#### 安装 PhpStorm – PHP IDE
```
$ sudo snap install phpstorm --classic
```
#### 安装 WebStorm – JavaScript IDE
```
$ sudo snap install webstorm --classic
```
#### 安装 RubyMine – Ruby and Rails IDE
```
$ sudo snap install rubymine --classic
```
### 5、PowerShell
**PowerShell** 是一个用于管理 PC 自动化和配置的平台，它提供了一个带有相关脚本语言的命令行 shell。如果你认为它仅在 Windows 上可用，那么请再想一想。
```
$ sudo snap install powershell --classic
```
### 6、Ghost
**Ghost** 是一款现代桌面程序，可让用户在无干扰的环境中管理多个 Ghost 博客、杂志、在线出版物等。
```
$ sudo snap install ghost-desktop
```
### 7、MySQL Workbench
**MySQL Workbench** 是一个 GUI 程序，用于设计和管理集成 SQL 功能的数据库。
* [**下载 MySQL Workbench**](https://dev.mysql.com/downloads/workbench/)
### 8、PlayOnLinux 中的 Adobe App Suite
你可能错过了我们在 [PlayOnLinux](https://www.fossmint.com/playonlinux-another-open-source-solution-for-linux-game-lovers/) 上发表的文章，所以这是另一个了解的机会。
PlayOnLinux 基本上是 **wine** 的改进版本，允许用户更轻松地安装 Adobe 的创意云程序。请注意，试用和订阅限制仍然适用。
* [**如何使用 PlayOnLinux**](https://www.fossmint.com/adobe-creative-cloud-install-adobe-apps-on-linux/)
### 9、Slack
这据说是开发人员和项目经理之间最常用的团队沟通软件，**Slack** 提供了每个人似乎无法满足的有各种文档和消息管理功能的工作空间。
```
$ sudo snap install slack --classic
```
### 10、Blender
**Blender** 是最受欢迎的 3D 创作程序之一。它是免费的、开源的，并且支持完整 3D 管道。
```
$ sudo snap install blender --classic
```
就是这些了！我们知道列表还有很多，但我们只能列出这么多。我们是否省略了你认为应该将其列入清单的任何程序？在下面的评论栏添加你的建议。
---
via: <https://www.fossmint.com/install-popular-windows-apps-on-linux/>
作者：[Martins D. Okoi](https://www.fossmint.com/author/dillivine/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
五个 Linux 上的开源角色扮演游戏
|
Joshua Allen Holm
|
https://opensource.com/article/18/8/role-playing-games-linux
|
换一个新的身份，并用这些开源的角色扮演游戏探索新世界。
|
/data/attachment/album/201809/09/182317teeekftygmzsqyfb.jpg.thumb.jpg
|
/data/attachment/album/201809/09/182317teeekftygmzsqyfb.jpg
| true | false | true |
lujun9972
|
hopefully2333
|
wxy
| false |
[
"游戏"
] |
分享
|
{
"viewnum": 6471,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
换一个新的身份，并用这些开源的角色扮演游戏探索新世界。
| 2018-09-09T18:23:14 | 2018-09-09T18:23:14 | 9,996 |
/article-9996-1.html
|
>
> 换一个新的身份，并用这些开源的角色扮演游戏探索新世界。
>
>
>
游戏是 Linux 的传统弱项之一，感谢 Steam、GOG 和其他的游戏开发商将商业游戏移植到了多个操作系统，Linux 的这个弱项在近几年有所改观，但是这些游戏通常都不是开源的。当然，这些游戏可以在开源系统上运行，但是对于开源的纯粹主义者来说这还不够好。
那么，有没有一款能让只使用自由开源软件的人在不影响他们开源理念的情况下也能享受到可靠游戏体验的精致游戏呢？
当然有啦！虽然开源游戏不太可能和拥有大量开发预算的 3A 级大作相媲美，但有许多类型的开源游戏也很有趣，而且它们可以直接从大多数主要的 Linux 发行版的仓库中进行安装。即使某个游戏没有被某些仓库打包，你也可以很简单地从这个游戏的官网下载它，并进行安装和运行。
这篇文章着眼于角色扮演游戏，我已经写过关于[街机游戏](https://opensource.com/article/18/1/arcade-games-linux)、[棋牌游戏](https://opensource.com/article/18/3/card-board-games-linux)、[益智游戏](https://opensource.com/article/18/6/puzzle-games-linux)，以及[赛车和飞行游戏](https://opensource.com/article/18/7/racing-flying-games-linux)。在本系列的最后一篇文章中，我打算覆盖战略游戏和模拟游戏这两方面。
### Endless Sky
[Endless Sky](https://endless-sky.github.io/) 是 Ambrosia Software 的 [Escape Velocity](https://en.wikipedia.org/wiki/Escape_Velocity_(video_game)) 系列的开源克隆品。玩家乘坐一艘宇宙飞船，在不同的世界之间旅行来运送货物和乘客，并在沿途中承接其他任务，或者玩家也可以变成海盗，并从其他货船中偷取货物。这个游戏让玩家自己决定要如何去体验这个游戏，以太阳系为背景的超大地图是非常具有探索性的。Endless Sky 是那些违背正常游戏类别分类的游戏之一。但这个兼具动作、角色扮演、太空模拟和交易这四种类型的游戏非常值得一试。
如果要安装 Endless Sky ，请运行下面的命令。
在 Fedora 上：
```
dnf install endless-sky
```
在 Debian/Ubuntu 上：
```
apt install endless-sky
```
### FreeDink
[FreeDink](http://www.gnu.org/software/freedink/) 是 [Dink Smallwood](http://www.rtsoft.com/pages/dink.php) 的开源版本，Dink Smallwood 是一个由 RTSoft 在 1997 年发售的动作角色扮演游戏。Dink Smallwood 在 1999 年时变为了免费游戏，并在 2003 年时公布了源代码。在 2008 年时，游戏的数据除了少部分的声音文件，都在开源协议下进行了开源。FreeDink 用一些替代的声音文件替换了缺少的那部分文件，来提供了一个完整的游戏。游戏的玩法类似于任天堂的[塞尔达传说](https://en.wikipedia.org/wiki/The_Legend_of_Zelda)系列。玩家控制的角色和 Dink Smallwood 同名，他在从一个任务地点移动到下一个任务地点的时候，探索这个充满隐藏物品和隐藏洞穴的世界地图。由于这个游戏的年龄，FreeDink 不能和现代的商业游戏相抗衡，但它仍然是一个拥有着有趣故事的有趣的游戏。游戏可以通过 [D-Mods](http://www.dinknetwork.com/files/category_dmod/) 进行扩展，D-Mods 是提供额外任务的附加模块，但是 D-Mods 在复杂性、质量，和年龄适应性上确实有很大的差异。游戏主要适合青少年，但也有部分额外组件适用于成年玩家。
要安装 FreeDink ，请运行下面的命令。
在 Fedora 上：
```
dnf install freedink
```
在 Debian/Ubuntu 上：
```
apt install freedink
```
### ManaPlus
从技术上讲，[ManaPlus](http://manaplus.org/) 本身并不是一个游戏，它是一个访问各种大型多人在线角色扮演游戏的客户端。[The Mana World](http://www.themanaworld.org/) 和 [Evol Online](http://evolonline.org/) 是两款可以通过 ManaPlus 访问的开源游戏，但是游戏的服务器不在那里。这个游戏的 2D 精灵图像让人想起超级任天堂游戏，虽然 ManaPlus 支持的游戏没有一款能像商业游戏那样受欢迎的，但它们都有一个有趣的世界，并且在绝大部分时间里都有至少一小部分玩家在线。一个玩家不太可能遇到很多的其他玩家，但通常都能有足够的人一起在这个 [MMORPG](https://en.wikipedia.org/wiki/Massively_multiplayer_online_role-playing_game) 游戏里进行冒险，而不是一个需要连接到服务器的单机游戏。Mana World 和 Evol Online 的开发者联合起来进行未来的开发，但是对于目前而言，Mana World 的历史服务器和 Evol Online 提供了不同的游戏体验。
要安装 ManaPlus，请运行下面的命令。
在 Fedora 上：
```
dnf install manaplus
```
在 Debian/Ubuntu 上：
```
apt install manaplus
```
### Minetest
使用 [Minetest](https://www.minetest.net/) 来在一个开放式世界里进行探索和创造，Minetest 是 Minecraft 的克隆品。就像它所基于的 Minecraft 一样，Minetest 提供了一个开放的世界，玩家可以在这个世界里探索和创造他们想要的一切。Minetest 提供了各种各样的方块和工具，对于想要一个比 Minecraft 更加开放的游戏的人来说，Minetest 是一个很好的替代品。除了基本的游戏之外，Minetest 还可以通过[额外的模块](https://wiki.minetest.net/Mods)进行可扩展，增加更多的选项。
如果要安装 Minetest ，请运行下面的命令。
在 Fedora 上：
```
dnf install minetest
```
在 Debian/Ubuntu 上：
```
apt install minetest
```
### NetHack
[NetHack](https://www.nethack.org/) 是一款经典的 [Roguelike](https://en.wikipedia.org/wiki/Roguelike) 类型的角色扮演游戏，玩家可以从不同的角色种族、分类和阵营中进行选择，来探索这个多层次的地下城。这个游戏的目的就是找回 Yendor 的护身符，玩家从地下层的第一层开始探索，并尝试向下一层移动，每一层都是随机生成的，这样每次都能获得不同的游戏体验。虽然这个游戏只具有 ASCII 图形和基本图形，但是游戏玩法的深度能够弥补画面的不足。玩家如果想要更好一些的画面的话，可能就需要去查看 [NetHack 的 Vulture](http://www.darkarts.co.za/vulture-for-nethack) 了，这个方式可以提供更好的图像、声音和背景音乐。
如果要安装 NetHack ，请运行下面的命令。
在 Fedora 上：
```
dnf install nethack
```
在 Debian/Ubuntu 上：
```
apt install nethack-x11 or apt install nethack-console
```
我有错过了你最喜欢的角色扮演游戏吗？请在下面的评论区分享出来。
---
via: <https://opensource.com/article/18/8/role-playing-games-linux>
作者：[Joshua Allen Holm](https://opensource.com/users/holmja) 选题：[lujun9972](https://github.com/lujun9972) 译者：[hopefully2333](https://github.com/hopefully2333) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Scrot：让你在命令行中进行截屏更加简单
|
Scott Nesbitt
|
https://opensource.com/article/17/11/taking-screen-captures-linux-command-line-scrot
|
Scrot 是一个简单、灵活，并且提供了许多选项的 Linux 命令行截屏工具。
|
/data/attachment/album/201809/09/183423ba9pf6yf6rwywgrm.png.thumb.jpg
|
/data/attachment/album/201809/09/183423ba9pf6yf6rwywgrm.png
| true | false | true |
ucasFL
|
wxy
| false |
[
"截屏"
] |
分享
|
{
"viewnum": 8006,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Scrot 是一个简单、灵活，并且提供了许多选项的 Linux 命令行截屏工具。
| 2018-09-09T18:34:00 | 2018-09-09T18:34:00 | 9,997 |
/article-9997-1.html
|
>
> Scrot 是一个简单、灵活，并且提供了许多选项的 Linux 命令行截屏工具。
>
>
>
Linux 桌面上有许多用于截屏的优秀工具，比如 [Ksnapshot](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/community-penguins-osdc-lead.png?itok=BmqsAF4A) 和 [Shutter](https://www.kde.org/applications/graphics/ksnapshot/) 。甚至 GNOME 桌面自带的简易截屏工具也能够很好的工作。但是，如果你很少截屏，或者你使用的 Linux 发行版没有内建截屏工具，或者你使用的是一台资源有限的老电脑，那么你该怎么办呢？
或许你可以转向命令行，使用一个叫做 [Scrot](https://github.com/dreamer/scrot) 的实用工具。它能够完成简单的截屏工作，同时它所具有的一些特性也许会让你感到非常惊喜。
### 走近 Scrot
许多 Linux 发行版都会预先安装上 Scrot ，可以输入 `which scrot` 命令来查看系统中是否安装有 Scrot 。如果没有，那么可以使用你的 Linux 发行版的包管理器来安装。如果你想从源代码编译安装，那么也可以从 [GitHub](http://manpages.ubuntu.com/manpages/precise/man1/scrot.1.html) 上下载源代码。
如果要进行截屏，首先打开一个终端窗口，然后输入 `scrot [filename]` ，`[filename]` 是你想要保存的图片文件的名字（比如 `desktop.png`）。如果缺省了该参数，那么 scrot 会自动创建一个名字，比如 `2017-09-24-185009_1687x938_scrot.png` 。（这个名字缺乏了对图片内容的描述，这就是为什么最好在命令中指定一个名字作为参数。）
如果不带任何参数运行 Scrot，那么它将会对整个桌面进行截屏。如果不想这样，那么你也可以对屏幕中的一个小区域进行截图。
### 对单一窗口进行截屏
可以通过输入 `scrot -u [filename]` 命令来对一个窗口进行截屏。
`-u` 选项告诉 Scrot 对当前窗口进行截屏，这通常是我们正在工作的终端窗口，也许不是你想要的。
如果要对桌面上的另一个窗口进行截屏，需要输入 `scrot -s [filename]` 。
`-s` 选项可以让你做下面两件事的其中一件：
* 选择一个打开着的窗口
* 在一个窗口的周围或一片区域画一个矩形进行捕获
你也可以设置一个时延，这样让你能够有时间来选择你想要捕获的窗口。可以通过 `scrot -u -d [num] [filename]` 来设置时延。
`-d` 选项告诉 Scrot 在捕获窗口前先等待一段时间，`[num]` 是需要等待的秒数。指定为 `-d 5` （等待 5 秒）应该能够让你有足够的时间来选择窗口。
### 更多有用的选项
Scrot 还提供了许多额外的特性（绝大多数我从来没有使用过）。下面是我发现的一些有用的选项：
* `-b` 捕获窗口的边界
* `-t` 捕获窗口并创建一个缩略图。当你需要把截图张贴到网上的时候，这会非常有用
* `-c` 当你同时使用了 `-d` 选项的时候，在终端中创建倒计时
如果你想了解 Scrot 的其他选项，可以在终端中输入 `man scrot` 来查看它的手册，或者[在线阅读](https://github.com/dreamer/scrot)。然后开始使用 Scrot 进行截屏。
虽然 Scrot 很简单，但它的确能够工作得很好。
---
via: <https://opensource.com/article/17/11/taking-screen-captures-linux-command-line-scrot>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Etcher.io 入门
|
Don Watkins
|
https://opensource.com/article/18/7/getting-started-etcherio
|
用这个易用的媒体创建工具来创建一个可引导的 USB 盘或 SD 卡。
|
/data/attachment/album/201809/09/185015rkz8uoq4cklqckxl.jpg.thumb.jpg
|
/data/attachment/album/201809/09/185015rkz8uoq4cklqckxl.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"可引导",
"USB"
] |
分享
|
{
"viewnum": 6436,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用这个易用的媒体创建工具来创建一个可引导的 USB 盘或 SD 卡。
| 2018-09-09T18:50:27 | 2018-09-09T18:50:27 | 9,998 |
/article-9998-1.html
|
>
> 用这个易用的媒体创建工具来创建一个可引导的 USB 盘或 SD 卡。
>
>
>
可启动 USB 盘是尝试新的 Linux 发行版的很好的方式，以便在安装之前查看你是否喜欢它。虽然一些 Linux 发行版（如 [Fedora](https://getfedora.org/en_GB/workstation/download/)）可以轻松创建可启动媒体，但大多数其他发行版提供 ISO 或镜像文件，并将创建媒体决定留给用户。用户总是可以选择使用 `dd` 在命令行上创建媒体——但让我们面对现实，即使对于最有经验的用户来说，这仍然很痛苦。也有一些其它程序，如 Mac 上的 UnetBootIn、Disk Utility 和 Windows 上的 Win32DiskImager，它们都可以创建可启动的 USB。
### 安装 Etcher
大约 18 个月前，我遇到了 [Etcher.io](http://etcher.io)，这是一个很棒的开源项目，可以在 Linux、Windows 或 MacOS 上轻松、简单地创建媒体。Etcher.io 已成为我为 Linux 创建可启动媒体的“首选”程序。我可以轻松下载 ISO 或 IMG 文件并将其刻录到闪存和 SD 卡。这是一个 [Apache 2.0](https://github.com/resin-io/etcher/blob/master/LICENSE) 许可证下的开源项目，[源代码](https://github.com/resin-io/etcher) 可在 GitHub 上获得。
进入 [Etcher.io](https://etcher.io/) 网站，然后单击适用于你的操作系统：32 位或 64 位 Linux、32 位或 64 位 Windows 或 MacOS 的下载链接。
Etcher 在 GitHub 仓库中提供了很好的指导，可以将 Etcher 添加到你的 Linux 实用程序集合中。
如果你使用的是 Debian 或 Ubuntu，请添加 Etcher Debian 仓库：
```
$echo "deb https://dl.bintray.com/resin-io/debian stable etcher" | sudo tee /etc/apt/sources.list.d/etcher.list
```
信任 Bintray.com GPG 密钥
```
$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 379CE192D401AB61
```
然后更新你的系统并安装：
```
$ sudo apt-get update
$ sudo apt-get install etcher-electron
```
如果你使用的是 Fedora 或 Red Hat Enterprise Linux，请添加 Etcher RPM 仓库：
```
$ sudo wget https://bintray.com/resin-io/redhat/rpm -O /etc/yum.repos.d/bintray-resin-io-redhat.repo
```
使用以下任一方式更新和安装：
```
$ sudo yum install -y etcher-electron
```
或者：
```
$ sudo dnf install -y etcher-electron
```
### 创建可启动盘
除了为 Ubuntu、EndlessOS 和其他版本的 Linux 创建可启动镜像之外，我还使用 Etcher [创建 SD 卡镜像](https://www.raspberrypi.org/magpi/pi-sd-etcher/)用于树莓派。以下是如何创建可启动媒体。
首先，将要使用的 ISO 或镜像下载到计算机。然后，启动 Etcher 并将 USB 或 SD 卡插入计算机。
单击 “Select Image”。在本例中，我想创建一个可启动的 USB 盘，以便在新计算机上安装 Ubermix。在我选择了我的 Ubermix 镜像文件并将我的 USB 盘插入计算机，Etcher.io “看到”了驱动器，我就可以开始在 USB 上安装 Ubermix 了。
在我点击 “Flash” 后，安装就开始了。所需时间取决于镜像的大小。在驱动器上安装镜像后，软件会验证安装。最后，一条提示宣布我的媒体创建已经完成。
如果您需要 [Etcher 的帮助](https://github.com/resin-io/etcher/blob/master/SUPPORT.md)，请通过其 [Discourse](https://forums.resin.io/c/etcher) 论坛联系社区。Etcher 非常易于使用，它已经取代了我所有其他的媒体创建工具，因为它们都不像 Etcher 那样轻松地完成工作。
---
via: <https://opensource.com/article/18/7/getting-started-etcherio>
作者：[Don Watkins](https://opensource.com/users/don-watkins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
LCTT 2018：五周年纪念日
|
老王
|
总结一下这两年我们做了什么，有什么不足，也发一些展望吧。
|
/data/attachment/album/201809/09/233431qhgn0dpho8691zhn.jpg.thumb.jpg
|
/data/attachment/album/201809/09/233431qhgn0dpho8691zhn.jpg
| true | false | false | true |
[
"LCTT"
] |
新闻
|
{
"viewnum": 9787,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 10279,
"displayorder": 0
}
] |
总结一下这两年我们做了什么，有什么不足，也发一些展望吧。
| 2018-09-09T23:34:00 | 2018-09-09T23:34:00 | 9,999 |
/article-9999-1.html
|
我是老王，可能大家有不少人知道我，由于历史原因，我有好几个生日（;o），但是这些年来，我又多了一个生日，或者说纪念日——每过两年，我就要严肃认真地写一篇 [LCTT](https://linux.cn/lctt) 生日纪念文章。
喏，这一篇，就是今年的了，LCTT 如今已经五岁了！
或许如同小孩子过生日总是比较快乐，而随着年岁渐长，过生日往往有不少负担——比如说，每次写这篇纪念文章时，我就需要回忆、反思这两年的做了些什么，往往颇为汗颜。
不过不管怎么说，总要总结一下这两年我们做了什么，有什么不足，也发一些展望吧。
### 江山代有英豪出
LCTT，如同一般的开源贡献组织，总是有不断的新老传承。我们的翻译组，也有不少成员，由于工作学习的原因，慢慢淡出，但同时，也不断有新的成员加入并接过前辈手中的旗帜（就是没人接我的）。
>
> **加入方式**
>
>
> 请首先加入翻译组的 QQ 群，群号是：**198889102**，加群时请说明是“**志愿者**”。加入后记得修改您的群名片为您的 GitHub 的 ID。
>
>
> 加入的成员，请先阅读 [WIKI 如何开始](https://github.com/LCTT/TranslateProject/wiki/01-%E5%A6%82%E4%BD%95%E5%BC%80%E5%A7%8B)。
>
>
>
比如说，我们这两年来，oska874 承担了主要的选题工作，然后 lujun9972 适时的出现接过了不少选题工作；再比如说，qhwdw 出现后承担了大量繁难文章的翻译，pityonline 则专注于校对，甚至其校对的严谨程度让我都甘拜下风。还有 MjSeven 也同 qhwdw 一样，以极高的翻译频率从一星译者迅速登顶五星译者。当然，还有 Bestony、Locez、VizV 等人为 LCTT 提供了不少技术支持和开发工作。
### 硕果累累
我们并没有特别的招新渠道，但是总是时不时会有新的成员慕名而来，到目前为止，我们已经有 [331](https://linux.cn/lctt-list) 位做过贡献的成员，已经翻译发布了 3885 篇译文，合计字节达 33MB 之多！
这两年，我们不但翻译了很多技术、新闻和评论类文章，也新增了新的翻译类型：[漫画](https://linux.cn/talk/comic/)，其中一些漫画得到了很多好评。
我们发布的文章有一些达到了 100000+ 的访问量，这对于我们这种技术垂直内容可不容易。
而同时，[Linux 中国](https://linux.cn/)也发布了近万篇文章，而这一篇，应该就是第 [9999](/article-9999-1.html) 篇文章，我们将在明天，进入新的篇章。
### 贡献者主页和贡献者证书
为了彰显诸位贡献者的贡献，我们为每位贡献者创立的自己的专页，并据此建立了[排行榜](https://linux.cn/lctt-list)。
同时，我们还特意请 Bestony 和“一一”设计开发和”贡献者证书”，大家可以在 [LCTT 贡献平台](https://lctt.linux.cn/)中领取。
### 规则进化
LCTT 最初创立时，甚至都没有采用 PR 模式。但是随着贡献者的增多，我们也逐渐在改善我们的流程、方法。
之前采用了很粗糙的 PR 模式，对 PR 中的文件、提交乃至于信息都没有进行硬性约束。后来在 VizV 的帮助下，建立了对 PR 的合规性检查；又在 pityonline 的督促下，采用了更为严格的 PR 审查机制。
LCTT 创立几年来，我们的一些流程和规范，已经成为其它一些翻译组的参考范本，我们也希望我们的这些经验，可以进一步帮助到其它的开源社区。
### 仓库重建和版权问题
今年还发生一次严重的事故，由于对选题来源把控不严和对版权问题没有引起足够的重视，我们引用的一篇文章违背了原文的版权规定，结果被原文作者投诉到 GitHub。而我并没有及时看到 GitHub 给我发的 DMCA 处理邮件，因此错过了处理窗口期，从而被 GitHub 将整个库予以删除。
出现这样的重大失误之后，经过大家的帮助，我们历经周折才将仓库基本恢复。这要特别感谢 VizV 的辛苦工作。
在此之后，我们对译文选文的规则进行了梳理，并全面清查了文章版权。这个教训对我们来说弥足沉重。
### 通证时代
在 Linux 中国及 LCTT 发展过程中，我一直小心翼翼注意商业化的问题。严格来说，没有经济支持的开源组织如同无根之木，无源之水，是长久不了的。而商业化的技术社区又难免为了三斗米而折腰。所以往往很多技术社区要么渐渐凋零，要么就变成了商业机构。
从中国电信辞职后，我专职运营 Linux 中国这个开源社区已经近三年了，其间也有一些商业性收入，但是仅能勉强承担基本的运营费用。
这种尴尬的局面，使我，以及其它的开源社区同仁们纷纷寻求更好的发展之路。
去年参加中国开源年会时，在闭门会上，大家的讨论启发了我和诸位同仁，我们认为，开源社区结合通证经济，似乎是一条可行的开源社区发展之路。
今年 8 月 1 日，我们经过了半年的论证和实验，[发布了社区通证 LCCN](/article-9886-1.html)，并已经初步发放到了各位译者手中。我们还在继续建设通证生态各种工具，如合约、交易商城等。
我们希望能够通过通证为开源社区转入新的活力，也愿意将在探索道路上遇到的问题和解决的思路、工具链分享给更多的社区。
### 总结
从上一次总结以来，这又是七百多天，时光荏苒，而 LCTT 的创立也近两千天了。我希望，我们的翻译组以及更多的贡献者可以在通证经济的推动下，找到自洽、自治的发展道路；也希望能有更多的贡献者涌现出来接过我们的大旗，将开源发扬光大。
wxy
2018/9/9 夜
|
||||
深入理解 ext4 等 Linux 文件系统
|
Jim Salter
|
https://opensource.com/article/18/4/ext4-filesystem
|
了解 ext4 的历史，包括其与 ext3 和之前的其它文件系统之间的区别。
|
/data/attachment/album/201809/11/095727zmpym6l4r2401gkc.jpg.thumb.jpg
|
/data/attachment/album/201809/11/095727zmpym6l4r2401gkc.jpg
| true | false | true |
HardworkFish
|
wxy, pityonline
| true |
[
"ext4",
"文件系统"
] |
技术
|
{
"viewnum": 28860,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8685,
"displayorder": 0
}
] |
了解 ext4 的历史，包括其与 ext3 和之前的其它文件系统之间的区别。
| 2018-09-11T09:58:00 | 2018-09-11T09:58:00 | 10,000 |
/article-10000-1.html
|
>
> 了解 ext4 的历史，包括其与 ext3 和之前的其它文件系统之间的区别。
>
>
>
目前的大部分 Linux 文件系统都默认采用 ext4 文件系统，正如以前的 Linux 发行版默认使用 ext3、ext2 以及更久前的 ext。
对于不熟悉 Linux 或文件系统的朋友而言，你可能不清楚 ext4 相对于上一版本 ext3 带来了什么变化。你可能还想知道在一连串关于替代的文件系统例如 Btrfs、XFS 和 ZFS 不断被发布的情况下，ext4 是否仍然能得到进一步的发展。
在一篇文章中，我们不可能讲述文件系统的所有方面，但我们尝试让你尽快了解 Linux 默认文件系统的发展历史，包括它的诞生以及未来发展。
我仔细研究了维基百科里的各种关于 ext 文件系统文章、kernel.org 的 wiki 中关于 ext4 的条目以及结合自己的经验写下这篇文章。
### ext 简史
#### MINIX 文件系统
在有 ext 之前，使用的是 MINIX 文件系统。如果你不熟悉 Linux 历史，那么可以理解为 MINIX 是用于 IBM PC/AT 微型计算机的一个非常小的类 Unix 系统。Andrew Tannenbaum 为了教学的目的而开发了它，并于 1987 年发布了源代码（以印刷版的格式！）。
*IBM 1980 中期的 PC/AT，[MBlairMartin](https://commons.wikimedia.org/wiki/File:IBM_PC_AT.jpg)，[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en)*
虽然你可以细读 MINIX 的源代码，但实际上它并不是自由开源软件（FOSS）。出版 Tannebaum 著作的出版商要求你花 69 美元的许可费来运行 MINIX，而这笔费用包含在书籍的费用中。尽管如此，在那时来说非常便宜，并且 MINIX 的使用得到迅速发展，很快超过了 Tannebaum 当初使用它来教授操作系统编码的意图。在整个 20 世纪 90 年代，你可以发现 MINIX 的安装在世界各个大学里面非常流行。而此时，年轻的 Linus Torvalds 使用 MINIX 来开发原始 Linux 内核，并于 1991 年首次公布，而后在 1992 年 12 月在 GPL 开源协议下发布。
但是等等，这是一篇以 *文件系统* 为主题的文章不是吗？是的，MINIX 有自己的文件系统，早期的 Linux 版本依赖于它。跟 MINIX 一样，Linux 的文件系统也如同玩具那般小 —— MINIX 文件系统最多能处理 14 个字符的文件名，并且只能处理 64MB 的存储空间。到了 1991 年，一般的硬盘尺寸已经达到了 40-140 MB。很显然，Linux 需要一个更好的文件系统。
#### ext
当 Linus 开发出刚起步的 Linux 内核时，Rémy Card 从事第一代的 ext 文件系统的开发工作。ext 文件系统在 1992 年首次实现并发布 —— 仅在 Linux 首次发布后的一年！—— ext 解决了 MINIX 文件系统中最糟糕的问题。
1992 年的 ext 使用在 Linux 内核中的新虚拟文件系统（VFS）抽象层。与之前的 MINIX 文件系统不同的是，ext 可以处理高达 2 GB 存储空间并处理 255 个字符的文件名。
但 ext 并没有长时间占统治地位，主要是由于它原始的时间戳（每个文件仅有一个时间戳，而不是今天我们所熟悉的有 inode、最近文件访问时间和最新文件修改时间的时间戳。）仅仅一年后，ext2 就替代了它。
#### ext2
Rémy 很快就意识到 ext 的局限性，所以一年后他设计出 ext2 替代它。当 ext 仍然根植于 “玩具” 操作系统时，ext2 从一开始就被设计为一个商业级文件系统，沿用 BSD 的 Berkeley 文件系统的设计原理。
ext2 提供了 GB 级别的最大文件大小和 TB 级别的文件系统大小，使其在 20 世纪 90 年代的地位牢牢巩固在文件系统大联盟中。很快它被广泛地使用，无论是在 Linux 内核中还是最终在 MINIX 中，且利用第三方模块可以使其应用于 MacOS 和 Windows。
但这里仍然有一些问题需要解决：ext2 文件系统与 20 世纪 90 年代的大多数文件系统一样，如果在将数据写入到磁盘的时候，系统发生崩溃或断电，则容易发生灾难性的数据损坏。随着时间的推移，由于碎片（单个文件存储在多个位置，物理上其分散在旋转的磁盘上），它们也遭受了严重的性能损失。
尽管存在这些问题，但今天 ext2 还是用在某些特殊的情况下 —— 最常见的是，作为便携式 USB 驱动器的文件系统格式。
#### ext3
1998 年，在 ext2 被采用后的 6 年后，Stephen Tweedie 宣布他正在致力于改进 ext2。这成了 ext3，并于 2001 年 11 月在 2.4.15 内核版本中被采用到 Linux 内核主线中。
*20 世纪 90 年代中期的 Packard Bell 计算机，[Spacekid](https://commons.wikimedia.org/wiki/File:Old_packard_bell_pc.jpg)，[CC0](https://creativecommons.org/publicdomain/zero/1.0/deed.en)*
在大部分情况下，ext2 在 Linux 发行版中工作得很好，但像 FAT、FAT32、HFS 和当时的其它文件系统一样 —— 在断电时容易发生灾难性的破坏。如果在将数据写入文件系统时候发生断电，则可能会将其留在所谓 *不一致* 的状态 —— 事情只完成一半而另一半未完成。这可能导致大量文件丢失或损坏，这些文件与正在保存的文件无关甚至导致整个文件系统无法卸载。
ext3 和 20 世纪 90 年代后期的其它文件系统，如微软的 NTFS，使用 *日志* 来解决这个问题。日志是磁盘上的一种特殊的分配区域，其写入被存储在事务中；如果该事务完成磁盘写入，则日志中的数据将提交给文件系统自身。如果系统在该操作提交前崩溃，则重新启动的系统识别其为未完成的事务而将其进行回滚，就像从未发生过一样。这意味着正在处理的文件可能依然会丢失，但文件系统 *本身* 保持一致，且其它所有数据都是安全的。
在使用 ext3 文件系统的 Linux 内核中实现了三个级别的日志记录方式：<ruby> 日记 <rt> journal </rt></ruby>、<ruby> 顺序 <rt> ordered </rt></ruby>和<ruby> 回写 <rt> writeback </rt></ruby>。
* **日记** 是最低风险模式，在将数据和元数据提交给文件系统之前将其写入日志。这可以保证正在写入的文件与整个文件系统的一致性，但其显著降低了性能。
* **顺序** 是大多数 Linux 发行版默认模式；顺序模式将元数据写入日志而直接将数据提交到文件系统。顾名思义，这里的操作顺序是固定的：首先，元数据提交到日志；其次，数据写入文件系统，然后才将日志中关联的元数据更新到文件系统。这确保了在发生崩溃时，那些与未完整写入相关联的元数据仍在日志中，且文件系统可以在回滚日志时清理那些不完整的写入事务。在顺序模式下，系统崩溃可能导致在崩溃期间文件的错误被主动写入，但文件系统它本身 —— 以及未被主动写入的文件 —— 确保是安全的。
* **回写** 是第三种模式 —— 也是最不安全的日志模式。在回写模式下，像顺序模式一样，元数据会被记录到日志，但数据不会。与顺序模式不同，元数据和数据都可以以任何有利于获得最佳性能的顺序写入。这可以显著提高性能，但安全性低很多。尽管回写模式仍然保证文件系统本身的安全性，但在崩溃或崩溃之前写入的文件很容易丢失或损坏。
跟之前的 ext2 类似，ext3 使用 16 位内部寻址。这意味着对于有着 4K 块大小的 ext3 在最大规格为 16 TiB 的文件系统中可以处理的最大文件大小为 2 TiB。
#### ext4
Theodore Ts'o（是当时 ext3 主要开发人员）在 2006 年发表的 ext4，于两年后在 2.6.28 内核版本中被加入到了 Linux 主线。
Ts'o 将 ext4 描述为一个显著扩展 ext3 但仍然依赖于旧技术的临时技术。他预计 ext4 终将会被真正的下一代文件系统所取代。
*Dell Precision 380 工作站，[Lance Fisher](https://commons.wikimedia.org/wiki/File:Dell_Precision_380_Workstation.jpeg)，[CC BY-SA 2.0](https://creativecommons.org/licenses/by-sa/2.0/deed.en)*
ext4 在功能上与 ext3 在功能上非常相似，但支持大文件系统，提高了对碎片的抵抗力，有更高的性能以及更好的时间戳。
### ext4 vs ext3
ext3 和 ext4 有一些非常明确的差别，在这里集中讨论下。
#### 向后兼容性
ext4 特地设计为尽可能地向后兼容 ext3。这不仅允许 ext3 文件系统原地升级到 ext4；也允许 ext4 驱动程序以 ext3 模式自动挂载 ext3 文件系统，因此使它无需单独维护两个代码库。
#### 大文件系统
ext3 文件系统使用 32 位寻址，这限制它仅支持 2 TiB 文件大小和 16 TiB 文件系统系统大小（这是假设在块大小为 4 KiB 的情况下，一些 ext3 文件系统使用更小的块大小，因此对其进一步被限制）。
ext4 使用 48 位的内部寻址，理论上可以在文件系统上分配高达 16 TiB 大小的文件，其中文件系统大小最高可达 1000000 TiB（1 EiB）。在早期 ext4 的实现中有些用户空间的程序仍然将其限制为最大大小为 16 TiB 的文件系统，但截至 2011 年，e2fsprogs 已经直接支持大于 16 TiB 大小的 ext4 文件系统。例如，红帽企业 Linux 在其合同上仅支持最高 50 TiB 的 ext4 文件系统，并建议 ext4 卷不超过 100 TiB。
#### 分配方式改进
ext4 在将存储块写入磁盘之前对存储块的分配方式进行了大量改进，这可以显著提高读写性能。
##### 区段
<ruby> 区段 <rt> extent </rt></ruby>是一系列连续的物理块 (最多达 128 MiB，假设块大小为 4 KiB），可以一次性保留和寻址。使用区段可以减少给定文件所需的 inode 数量，并显著减少碎片并提高写入大文件时的性能。
##### 多块分配
ext3 为每一个新分配的块调用一次块分配器。当多个写入同时打开分配器时，很容易导致严重的碎片。然而，ext4 使用延迟分配，这允许它合并写入并更好地决定如何为尚未提交的写入分配块。
##### 持久的预分配
在为文件预分配磁盘空间时，大部分文件系统必须在创建时将零写入该文件的块中。ext4 允许替代使用 `fallocate()`，它保证了空间的可用性（并试图为它找到连续的空间），而不需要先写入它。这显著提高了写入和将来读取流和数据库应用程序的写入数据的性能。
##### 延迟分配
这是一个耐人寻味而有争议性的功能。延迟分配允许 ext4 等待分配将写入数据的实际块，直到它准备好将数据提交到磁盘。（相比之下，即使数据仍然在往写入缓存中写入，ext3 也会立即分配块。）
当缓存中的数据累积时，延迟分配块允许文件系统对如何分配块做出更好的选择，降低碎片（写入，以及稍后的读）并显著提升性能。然而不幸的是，它 *增加* 了还没有专门调用 `fsync()` 方法（当程序员想确保数据完全刷新到磁盘时）的程序的数据丢失的可能性。
假设一个程序完全重写了一个文件：
```
fd=open("file", O_TRUNC); write(fd, data); close(fd);
```
使用旧的文件系统，`close(fd);` 足以保证 `file` 中的内容刷新到磁盘。即使严格来说，写不是事务性的，但如果文件关闭后发生崩溃，则丢失数据的风险很小。
如果写入不成功（由于程序上的错误、磁盘上的错误、断电等），文件的原始版本和较新版本都可能丢失数据或损坏。如果其它进程在写入文件时访问文件，则会看到损坏的版本。如果其它进程打开文件并且不希望其内容发生更改 —— 例如，映射到多个正在运行的程序的共享库。这些进程可能会崩溃。
为了避免这些问题，一些程序员完全避免使用 `O_TRUNC`。相反，他们可能会写入一个新文件，关闭它，然后将其重命名为旧文件名：
```
fd=open("newfile"); write(fd, data); close(fd); rename("newfile", "file");
```
在 *没有* 延迟分配的文件系统下，这足以避免上面列出的潜在的损坏和崩溃问题：因为 `rename()` 是原子操作，所以它不会被崩溃中断；并且运行的程序将继续引用旧的文件。现在 `file` 的未链接版本只要有一个打开的文件文件句柄即可。但是因为 ext4 的延迟分配会导致写入被延迟和重新排序，`rename("newfile", "file")` 可以在 `newfile` 的内容实际写入磁盘内容之前执行，这出现了并行进行再次获得 `file` 坏版本的问题。
为了缓解这种情况，Linux 内核（自版本 2.6.30）尝试检测这些常见代码情况并强制立即分配。这会减少但不能防止数据丢失的可能性 —— 并且它对新文件没有任何帮助。如果你是一位开发人员，请注意：保证数据立即写入磁盘的唯一方法是正确调用 `fsync()`。
#### 无限制的子目录
ext3 仅限于 32000 个子目录；ext4 允许无限数量的子目录。从 2.6.23 内核版本开始，ext4 使用 HTree 索引来减少大量子目录的性能损失。
#### 日志校验
ext3 没有对日志进行校验，这给处于内核直接控制之外的磁盘或自带缓存的控制器设备带来了问题。如果控制器或具自带缓存的磁盘脱离了写入顺序，则可能会破坏 ext3 的日记事务顺序，从而可能破坏在崩溃期间（或之前一段时间）写入的文件。
理论上，这个问题可以使用写入<ruby> 障碍 <rt> barrier </rt></ruby> —— 在安装文件系统时，你在挂载选项设置 `barrier=1`，然后设备就会忠实地执行 `fsync` 一直向下到底层硬件。通过实践，可以发现存储设备和控制器经常不遵守写入障碍 —— 提高性能（和跟竞争对手比较的性能基准），但增加了本应该防止数据损坏的可能性。
对日志进行校验和允许文件系统崩溃后第一次挂载时意识到其某些条目是无效或无序的。因此，这避免了回滚部分条目或无序日志条目的错误，并进一步损坏的文件系统 —— 即使部分存储设备假做或不遵守写入障碍。
#### 快速文件系统检查
在 ext3 下，在 `fsck` 被调用时会检查整个文件系统 —— 包括已删除或空文件。相比之下，ext4 标记了 inode 表未分配的块和扇区，从而允许 `fsck` 完全跳过它们。这大大减少了在大多数文件系统上运行 `fsck` 的时间，它实现于内核 2.6.24。
#### 改进的时间戳
ext3 提供粒度为一秒的时间戳。虽然足以满足大多数用途，但任务关键型应用程序经常需要更严格的时间控制。ext4 通过提供纳秒级的时间戳，使其可用于那些企业、科学以及任务关键型的应用程序。
ext3 文件系统也没有提供足够的位来存储 2038 年 1 月 18 日以后的日期。ext4 在这里增加了两个位，将 [Unix 纪元](https://en.wikipedia.org/wiki/Unix_time)扩展了 408 年。如果你在公元 2446 年读到这篇文章，你很有可能已经转移到一个更好的文件系统 —— 如果你还在测量自 1970 年 1 月 1 日 00:00（UTC）以来的时间，这会让我死后得以安眠。
#### 在线碎片整理
ext2 和 ext3 都不直接支持在线碎片整理 —— 即在挂载时会对文件系统进行碎片整理。ext2 有一个包含的实用程序 `e2defrag`，它的名字暗示 —— 它需要在文件系统未挂载时脱机运行。（显然，这对于根文件系统来说非常有问题。）在 ext3 中的情况甚至更糟糕 —— 虽然 ext3 比 ext2 更不容易受到严重碎片的影响，但 ext3 文件系统运行 `e2defrag` 可能会导致灾难性损坏和数据丢失。
尽管 ext3 最初被认为“不受碎片影响”，但对同一文件（例如 BitTorrent）采用大规模并行写入过程的过程清楚地表明情况并非完全如此。一些用户空间的手段和解决方法，例如 [Shake](https://vleu.net/shake/)，以这样或那样方式解决了这个问题 —— 但它们比真正的、文件系统感知的、内核级碎片整理过程更慢并且在各方面都不太令人满意。
ext4 通过 `e4defrag` 解决了这个问题，且是一个在线、内核模式、文件系统感知、块和区段级别的碎片整理实用程序。
### 正在进行的 ext4 开发
ext4，正如 Monty Python 中瘟疫感染者曾经说过的那样，“我还没死呢！”虽然它的[主要开发人员](http://www.linux-mag.com/id/7272/)认为它只是一个真正的[下一代文件系统](https://arstechnica.com/information-technology/2014/01/bitrot-and-atomic-cows-inside-next-gen-filesystems/)的权宜之计，但是在一段时间内，没有任何可能的候选人准备好（由于技术或许可问题）部署为根文件系统。
在未来的 ext4 版本中仍然有一些关键功能要开发，包括元数据校验和、一流的配额支持和大分配块。
#### 元数据校验和
由于 ext4 具有冗余超级块，因此为文件系统校验其中的元数据提供了一种方法，可以自行确定主超级块是否已损坏并需要使用备用块。可以在没有校验和的情况下，从损坏的超级块恢复 —— 但是用户首先需要意识到它已损坏，然后尝试使用备用方法手动挂载文件系统。由于在某些情况下，使用损坏的主超级块安装文件系统读写可能会造成进一步的损坏，即使是经验丰富的用户也无法避免，这也不是一个完美的解决方案！
与 Btrfs 或 ZFS 等下一代文件系统提供的极其强大的每块校验和相比，ext4 的元数据校验和的功能非常弱。但它总比没有好。虽然校验 **所有的事情** 都听起来很简单！—— 事实上，将校验和与文件系统连接到一起有一些重大的挑战；请参阅[设计文档](https://ext4.wiki.kernel.org/index.php/Ext4_Metadata_Checksums)了解详细信息。
#### 一流的配额支持
等等，配额？！从 ext2 出现的那天开始我们就有了这些！是的，但它们一直都是事后的添加的东西，而且它们总是犯傻。这里可能不值得详细介绍，但[设计文档](https://ext4.wiki.kernel.org/index.php/Design_For_1st_Class_Quota_in_Ext4)列出了配额将从用户空间移动到内核中的方式，并且能够更加正确和高效地执行。
#### 大分配块
随着时间的推移，那些讨厌的存储系统不断变得越来越大。由于一些固态硬盘已经使用 8K 硬件块大小，因此 ext4 对 4K 模块的当前限制越来越受到限制。较大的存储块可以显著减少碎片并提高性能，代价是增加“松弛”空间（当你只需要块的一部分来存储文件或文件的最后一块时留下的空间）。
你可以在[设计文档](https://ext4.wiki.kernel.org/index.php/Design_for_Large_Allocation_Blocks)中查看详细说明。
### ext4 的实际限制
ext4 是一个健壮、稳定的文件系统。如今大多数人都应该在用它作为根文件系统，但它无法处理所有需求。让我们简单地谈谈你不应该期待的一些事情 —— 现在或可能在未来：
虽然 ext4 可以处理高达 1 EiB 大小（相当于 1,000,000 TiB）大小的数据，但你 *真的* 不应该尝试这样做。除了能够记住更多块的地址之外，还存在规模上的问题。并且现在 ext4 不会处理（并且可能永远不会）超过 50-100 TiB 的数据。
ext4 也不足以保证数据的完整性。随着日志记录的重大进展又回到了 ext3 的那个时候，它并未涵盖数据损坏的许多常见原因。如果数据已经在磁盘上被[破坏](https://en.wikipedia.org/wiki/Data_degradation#Visual_example_of_data_degradation) —— 由于故障硬件，宇宙射线的影响（是的，真的），或者只是数据随时间衰减 —— ext4 无法检测或修复这种损坏。
基于上面两点，ext4 只是一个纯 *文件系统*，而不是存储卷管理器。这意味着，即使你有多个磁盘 —— 也就是奇偶校验或冗余，理论上你可以从 ext4 中恢复损坏的数据，但无法知道使用它是否对你有利。虽然理论上可以在不同的层中分离文件系统和存储卷管理系统而不会丢失自动损坏检测和修复功能，但这不是当前存储系统的设计方式，并且它将给新设计带来重大挑战。
### 备用文件系统
在我们开始之前，提醒一句：要非常小心，没有任何备用的文件系统作为主线内核的一部分而内置和直接支持！
即使一个文件系统是 *安全的*，如果在内核升级期间出现问题，使用它作为根文件系统也是非常可怕的。如果你没有充分的理由通过一个 chroot 去使用替代介质引导，耐心地操作内核模块、grub 配置和 DKMS……不要在一个很重要的系统中去掉预留的根文件。
可能有充分的理由使用你的发行版不直接支持的文件系统 —— 但如果你这样做，我强烈建议你在系统启动并可用后再安装它。（例如，你可能有一个 ext4 根文件系统，但是将大部分数据存储在 ZFS 或 Btrfs 池中。）
#### XFS
XFS 与非 ext 文件系统在 Linux 中的主线中的地位一样。它是一个 64 位的日志文件系统，自 2001 年以来内置于 Linux 内核中，为大型文件系统和高度并发性提供了高性能（即大量的进程都会立即写入文件系统）。
从 RHEL 7 开始，XFS 成为 Red Hat Enterprise Linux 的默认文件系统。对于家庭或小型企业用户来说，它仍然有一些缺点 —— 最值得注意的是，重新调整现有 XFS 文件系统是一件非常痛苦的事情，不如创建另一个并复制数据更有意义。
虽然 XFS 是稳定的且是高性能的，但它和 ext4 之间没有足够具体的最终用途差异，以值得推荐在非默认（如 RHEL7）的任何地方使用它，除非它解决了对 ext4 的特定问题，例如大于 50 TiB 容量的文件系统。
XFS 在任何方面都不是 ZFS、Btrfs 甚至 WAFL（一个专有的 SAN 文件系统）的“下一代”文件系统。就像 ext4 一样，它应该被视为一种更好的方式的权宜之计。
#### ZFS
ZFS 由 Sun Microsystems 开发，以 zettabyte 命名 —— 相当于 1 万亿 GB —— 因为它理论上可以解决大型存储系统。
作为真正的下一代文件系统，ZFS 提供卷管理（能够在单个文件系统中处理多个单独的存储设备），块级加密校验和（允许以极高的准确率检测数据损坏），[自动损坏修复](https://en.wikipedia.org/wiki/Data_degradation#Visual_example_of_data_degradation)（其中冗余或奇偶校验存储可用），[快速异步增量复制](https://arstechnica.com/information-technology/2015/12/rsync-net-zfs-replication-to-the-cloud-is-finally-here-and-its-fast/)，内联压缩等，[以及更多](https://arstechnica.com/information-technology/2014/02/ars-walkthrough-using-the-zfs-next-gen-filesystem-on-linux/)。
从 Linux 用户的角度来看，ZFS 的最大问题是许可证问题。ZFS 许可证是 CDDL 许可证，这是一种与 GPL 冲突的半许可的许可证。关于在 Linux 内核中使用 ZFS 的意义存在很多争议，其争议范围从“它是 GPL 违规”到“它是 CDDL 违规”到“它完全没问题，它还没有在法庭上进行过测试。”最值得注意的是，自 2016 年以来 Canonical 已将 ZFS 代码内联在其默认内核中，而且目前尚无法律挑战。
此时，即使我作为一个非常狂热于 ZFS 的用户，我也不建议将 ZFS 作为 Linux 的根文件系统。如果你想在 Linux 上利用 ZFS 的优势，用 ext4 设置一个小的根文件系统，然后将 ZFS 用在你剩余的存储上，把数据、应用程序以及你喜欢的东西放在它上面 —— 但把 root 分区保留在 ext4 上，直到你的发行版明确支持 ZFS 根目录。
#### Btrfs
Btrfs 是 B-Tree Filesystem 的简称，通常发音为 “butter” —— 由 Chris Mason 于 2007 年在 Oracle 任职期间发布。Btrfs 旨在跟 ZFS 有大部分相同的目标，提供多种设备管理、每块校验、异步复制、直列压缩等，[还有更多](https://arstechnica.com/information-technology/2014/01/bitrot-and-atomic-cows-inside-next-gen-filesystems/)。
截至 2018 年，Btrfs 相当稳定，可用作标准的单磁盘文件系统，但可能不应该依赖于卷管理器。与许多常见用例中的 ext4、XFS 或 ZFS 相比，它存在严重的性能问题，其下一代功能 —— 复制、多磁盘拓扑和快照管理 —— 可能非常多，其结果可能是从灾难性地性能降低到实际数据的丢失。
Btrfs 的维持状态是有争议的；SUSE Enterprise Linux 在 2015 年采用它作为默认文件系统，而 Red Hat 于 2017 年宣布它从 RHEL 7.4 开始不再支持 Btrfs。可能值得注意的是，该产品支持 Btrfs 部署用作单磁盘文件系统，而不是像 ZFS 中的多磁盘卷管理器，甚至 Synology 在它的存储设备使用 Btrfs，但是它在传统 Linux 内核 RAID（mdraid）之上分层来管理磁盘。
---
via: <https://opensource.com/article/18/4/ext4-filesystem>
作者：[Jim Salter](https://opensource.com/users/jim-salter) 译者：[HardworkFish](https://github.com/HardworkFish) 校对：[wxy](https://github.com/wxy), [pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Makefile 及其工作原理
|
Sachin Patil
|
https://opensource.com/article/18/8/what-how-makefile
|
用这个方便的工具来更有效的运行和编译你的程序。
|
/data/attachment/album/201809/11/100710bzutsa3tkygyue1h.png.thumb.jpg
|
/data/attachment/album/201809/11/100710bzutsa3tkygyue1h.png
| true | false | true |
lujun9972
|
zafiry
|
wxy
| false |
[
"make",
"Makefile",
"gcc"
] |
软件开发
|
{
"viewnum": 7817,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用这个方便的工具来更有效的运行和编译你的程序。
| 2018-09-11T10:06:00 | 2018-09-11T10:06:00 | 10,001 |
/article-10001-1.html
|
>
> 用这个方便的工具来更有效的运行和编译你的程序。
>
>
>
当你需要在一些源文件改变后运行或更新一个任务时，通常会用到 `make` 工具。`make` 工具需要读取一个 `Makefile`（或 `makefile`）文件，在该文件中定义了一系列需要执行的任务。你可以使用 `make` 来将源代码编译为可执行程序。大部分开源项目会使用 `make` 来实现最终的二进制文件的编译，然后使用 `make install` 命令来执行安装。
本文将通过一些基础和进阶的示例来展示 `make` 和 `Makefile` 的使用方法。在开始前，请确保你的系统中安装了 `make`。
### 基础示例
依然从打印 “Hello World” 开始。首先创建一个名字为 `myproject` 的目录，目录下新建 `Makefile` 文件，文件内容为：
```
say_hello:
echo "Hello World"
```
在 `myproject` 目录下执行 `make`，会有如下输出：
```
$ make
echo "Hello World"
Hello World
```
在上面的例子中，“say\_hello” 类似于其他编程语言中的函数名。这被称之为<ruby> 目标 <rt> target </rt></ruby>。在该目标之后的是预置条件或依赖。为了简单起见，我们在这个示例中没有定义预置条件。`echo ‘Hello World'` 命令被称为<ruby> 步骤 <rt> recipe </rt></ruby>。这些步骤基于预置条件来实现目标。目标、预置条件和步骤共同构成一个规则。
总结一下，一个典型的规则的语法为：
```
目标: 预置条件
<TAB> 步骤
```
作为示例，目标可以是一个基于预置条件（源代码）的二进制文件。另一方面，预置条件也可以是依赖其他预置条件的目标。
```
final_target: sub_target final_target.c
Recipe_to_create_final_target
sub_target: sub_target.c
Recipe_to_create_sub_target
```
目标并不要求是一个文件，也可以只是步骤的名字，就如我们的例子中一样。我们称之为“伪目标”。
再回到上面的示例中，当 `make` 被执行时，整条指令 `echo "Hello World"` 都被显示出来，之后才是真正的执行结果。如果不希望指令本身被打印处理，需要在 `echo` 前添加 `@`。
```
say_hello:
@echo "Hello World"
```
重新运行 `make`，将会只有如下输出：
```
$ make
Hello World
```
接下来在 `Makefile` 中添加如下伪目标：`generate` 和 `clean`：
```
say_hello:
@echo "Hello World"
generate:
@echo "Creating empty text files..."
touch file-{1..10}.txt
clean:
@echo "Cleaning up..."
rm *.txt
```
随后当我们运行 `make` 时，只有 `say_hello` 这个目标被执行。这是因为`Makefile` 中的第一个目标为默认目标。通常情况下会调用默认目标，这就是你在大多数项目中看到 `all` 作为第一个目标而出现。`all` 负责来调用它他的目标。我们可以通过 `.DEFAULT_GOAL` 这个特殊的伪目标来覆盖掉默认的行为。
在 `Makefile` 文件开头增加 `.DEFAULT_GOAL`：
```
.DEFAULT_GOAL := generate
```
`make` 会将 `generate` 作为默认目标：
```
$ make
Creating empty text files...
touch file-{1..10}.txt
```
顾名思义，`.DEFAULT_GOAL` 伪目标仅能定义一个目标。这就是为什么很多 `Makefile` 会包括 `all` 这个目标，这样可以调用多个目标。
下面删除掉 `.DEFAULT_GOAL`，增加 `all` 目标：
```
all: say_hello generate
say_hello:
@echo "Hello World"
generate:
@echo "Creating empty text files..."
touch file-{1..10}.txt
clean:
@echo "Cleaning up..."
rm *.txt
```
运行之前，我们再增加一些特殊的伪目标。`.PHONY` 用来定义这些不是文件的目标。`make` 会默认调用这些伪目标下的步骤，而不去检查文件名是否存在或最后修改日期。完整的 `Makefile` 如下：
```
.PHONY: all say_hello generate clean
all: say_hello generate
say_hello:
@echo "Hello World"
generate:
@echo "Creating empty text files..."
touch file-{1..10}.txt
clean:
@echo "Cleaning up..."
rm *.txt
```
`make` 命令会调用 `say_hello` 和 `generate`：
```
$ make
Hello World
Creating empty text files...
touch file-{1..10}.txt
```
`clean` 不应该被放入 `all` 中，或者被放入第一个目标中。`clean` 应当在需要清理时手动调用，调用方法为 `make clean`。
```
$ make clean
Cleaning up...
rm *.txt
```
现在你应该已经对 `Makefile` 有了基础的了解，接下来我们看一些进阶的示例。
### 进阶示例
#### 变量
在之前的实例中，大部分目标和预置条件是已经固定了的，但在实际项目中，它们通常用变量和模式来代替。
定义变量最简单的方式是使用 `=` 操作符。例如，将命令 `gcc` 赋值给变量 `CC`：
```
CC = gcc
```
这被称为递归扩展变量，用于如下所示的规则中：
```
hello: hello.c
${CC} hello.c -o hello
```
你可能已经想到了，这些步骤将会在传递给终端时展开为：
```
gcc hello.c -o hello
```
`${CC}` 和 `$(CC)` 都能对 `gcc` 进行引用。但如果一个变量尝试将它本身赋值给自己，将会造成死循环。让我们验证一下：
```
CC = gcc
CC = ${CC}
all:
@echo ${CC}
```
此时运行 `make` 会导致：
```
$ make
Makefile:8: *** Recursive variable 'CC' references itself (eventually). Stop.
```
为了避免这种情况发生，可以使用 `:=` 操作符（这被称为简单扩展变量）。以下代码不会造成上述问题：
```
CC := gcc
CC := ${CC}
all:
@echo ${CC}
```
#### 模式和函数
下面的 `Makefile` 使用了变量、模式和函数来实现所有 C 代码的编译。我们来逐行分析下：
```
# Usage:
# make # compile all binary
# make clean # remove ALL binaries and objects
.PHONY = all clean
CC = gcc # compiler to use
LINKERFLAG = -lm
SRCS := $(wildcard *.c)
BINS := $(SRCS:%.c=%)
all: ${BINS}
%: %.o
@echo "Checking.."
${CC} ${LINKERFLAG} $< -o $@
%.o: %.c
@echo "Creating object.."
${CC} -c $<
clean:
@echo "Cleaning up..."
rm -rvf *.o ${BINS}
```
* 以 `#` 开头的行是评论。
* `.PHONY = all clean` 行定义了 `all` 和 `clean` 两个伪目标。
* 变量 `LINKERFLAG` 定义了在步骤中 `gcc` 命令需要用到的参数。
* `SRCS := $(wildcard *.c)`：`$(wildcard pattern)` 是与文件名相关的一个函数。在本示例中，所有 “.c”后缀的文件会被存入 `SRCS` 变量。
* `BINS := $(SRCS:%.c=%)`：这被称为替代引用。本例中，如果 `SRCS` 的值为 `'foo.c bar.c'`，则 `BINS`的值为 `'foo bar'`。
* `all: ${BINS}` 行：伪目标 `all` 调用 `${BINS}` 变量中的所有值作为子目标。
* 规则：
```
%: %.o
@echo "Checking.."
${CC} ${LINKERFLAG} $< -o $@
```
下面通过一个示例来理解这条规则。假定 `foo` 是变量 `${BINS}` 中的一个值。`%` 会匹配到 `foo`（`%`匹配任意一个目标）。下面是规则展开后的内容：
```
foo: foo.o
@echo "Checking.."
gcc -lm foo.o -o foo
```
如上所示，`%` 被 `foo` 替换掉了。`$<` 被 `foo.o` 替换掉。`$<`用于匹配预置条件，`$@` 匹配目标。对 `${BINS}` 中的每个值，这条规则都会被调用一遍。
* 规则：
```
%.o: %.c
@echo "Creating object.."
${CC} -c $<
```
之前规则中的每个预置条件在这条规则中都会都被作为一个目标。下面是展开后的内容：
```
foo.o: foo.c
@echo "Creating object.."
gcc -c foo.c
```
* 最后，在 `clean` 目标中，所有的二进制文件和编译文件将被删除。
下面是重写后的 `Makefile`，该文件应该被放置在一个有 `foo.c` 文件的目录下：
```
# Usage:
# make # compile all binary
# make clean # remove ALL binaries and objects
.PHONY = all clean
CC = gcc # compiler to use
LINKERFLAG = -lm
SRCS := foo.c
BINS := foo
all: foo
foo: foo.o
@echo "Checking.."
gcc -lm foo.o -o foo
foo.o: foo.c
@echo "Creating object.."
gcc -c foo.c
clean:
@echo "Cleaning up..."
rm -rvf foo.o foo
```
关于 `Makefile` 的更多信息，[GNU Make 手册](https://www.gnu.org/software/make/manual/make.pdf)提供了更完整的说明和实例。
---
via: <https://opensource.com/article/18/8/what-how-makefile>
作者：[Sachin Patil](https://opensource.com/users/psachin) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Zafiry](https://github.com/zafiry) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Ubuntu 18.04 上更新固件
|
Abhishek Prakash
|
https://itsfoss.com/update-firmware-ubuntu/
|
通常，Ubuntu 和其他 Linux 中的默认软件中心会处理系统固件的更新。但是如果你遇到了错误，你可以使用 fwupd 命令行工具更新系统的固件。
|
/data/attachment/album/201809/11/101654yjcgatrggtpccoc1.jpg.thumb.jpg
|
/data/attachment/album/201809/11/101654yjcgatrggtpccoc1.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"固件"
] |
技术
|
{
"viewnum": 10254,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通常，Ubuntu 和其他 Linux 中的默认软件中心会处理系统固件的更新。但是如果你遇到了错误，你可以使用 fwupd 命令行工具更新系统的固件。
| 2018-09-11T10:17:17 | 2018-09-11T10:17:17 | 10,002 |
/article-10002-1.html
|
通常，Ubuntu 和其他 Linux 中的默认软件中心会处理系统固件的更新。但是如果你遇到了错误，你可以使用 `fwupd` 命令行工具更新系统的固件。
我使用 [Dell XPS 13 Ubuntu 版本](https://itsfoss.com/dell-xps-13-ubuntu-review/)作为我的主要操作系统。我全新[安装了 Ubuntu 18.04](https://itsfoss.com/install-ubuntu-dual-boot-mode-windows/)，我对硬件兼容性感到满意。蓝牙、外置 USB 耳机和扬声器、多显示器，一切都开箱即用。
困扰我的一件事是软件中心出现的一个[固件](https://en.wikipedia.org/wiki/Firmware)更新。
单击“更新”按钮会在几秒钟后出现错误。
错误消息是：
>
> Unable to update “Thunderbolt NVM for Xps Notebook 9360”: could not detect device after update: timed out while waiting for device
>
>
>
在这篇文章中，我将向你展示如何在 [Ubuntu](https://www.ubuntu.com/) 中更新系统固件。
### 在 Ubuntu 18.04 中更新固件
有一件事你应该知道 GNOME Software（即 Ubuntu 18.04 中的软件中心）也能够更新固件。但是在由于某种原因失败的情况下，你可以使用命令行工具 `fwupd`。
[fwupd](https://fwupd.org/) 是一个开源守护进程，可以处理基于 Linux 的系统中的固件升级。它由 GNOME 开发人员 [Richard Hughes](https://github.com/hughsie/fwupd) 创建。戴尔的开发人员也为这一开源工具的开发做出了贡献。
基本上，它使用 LVFS —— <ruby> Linux 供应商固件服务 <rt> Linux Vendor Firmware Service </rt></ruby>。硬件供应商将可再发行固件上传到 LVFS 站点，并且多亏 `fwupd`，你可以从操作系统内部升级这些固件。`fwupd` 得到了 Ubuntu 和 Fedora 等主要 Linux 发行版的支持。
首先打开终端并更新系统：
```
sudo apt update && sudo apt upgrade -y
```
之后，你可以逐个使用以下命令来启动守护程序，刷新可用固件更新列表并安装固件更新。
```
sudo service fwupd start
```
守护进程运行后，检查是否有可用的固件更新。
```
sudo fwupdmgr refresh
```
输出应如下所示：
```
Fetching metadata https://cdn.fwupd.org/downloads/firmware.xml.gz
Downloading… [****************************]
Fetching signature https://cdn.fwupd.org/downloads/firmware.xml.gz.asc
```
在此之后，运行固件更新：
```
sudo fwupdmgr update
```
固件更新的输出可能与此类似：
```
No upgrades for XPS 13 9360 TPM 2.0, current is 1.3.1.0: 1.3.1.0=same
No upgrades for XPS 13 9360 System Firmware, current is 0.2.8.1: 0.2.8.1=same, 0.2.7.1=older, 0.2.6.2=older, 0.2.5.1=older, 0.2.4.2=older, 0.2.3.1=older, 0.2.2.1=older, 0.2.1.0=older, 0.1.3.7=older, 0.1.3.5=older, 0.1.3.2=older, 0.1.2.3=older
Downloading 21.00 for XPS13 9360 Thunderbolt Controller…
Updating 21.00 on XPS13 9360 Thunderbolt Controller…
Decompressing… [***********]
Authenticating… [***********]
Restarting device… [***********]
```
这应该处理了在 Ubuntu 18.04 中的固件更新。我希望这篇文章可以帮助你在 Linux 中进行固件更新。
如果你有任何问题或建议，请在下面的评论栏留言。
---
via: <https://itsfoss.com/update-firmware-ubuntu/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Kubernetes 网络运维
|
Julia Evans
|
https://jvns.ca/blog/2017/10/10/operating-a-kubernetes-network/
|
运维联网软件是很难的
|
/data/attachment/album/201809/11/220025axeurt8duqlequks.jpeg.thumb.jpg
|
/data/attachment/album/201809/11/220025axeurt8duqlequks.jpeg
| true | false | true |
qhwdw
|
wxy
| false |
[
"Kubernetes",
"容器",
"网络"
] |
系统运维
|
{
"viewnum": 8212,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
运维联网软件是很难的
| 2018-09-11T22:01:24 | 2018-09-11T22:01:24 | 10,003 |
/article-10003-1.html
|
最近我一直在研究 Kubernetes 网络。我注意到一件事情就是，虽然关于如何设置 Kubernetes 网络的文章很多，也写得很不错，但是却没有看到关于如何去运维 Kubernetes 网络的文章、以及如何完全确保它不会给你造成生产事故。
在本文中，我将尽力让你相信三件事情（我觉得这些都很合理 :)）：
* 避免生产系统网络中断非常重要
* 运维联网软件是很难的
* 有关你的网络基础设施的重要变化值得深思熟虑，以及这种变化对可靠性的影响。虽然非常“牛x”的谷歌人常说“这是我们在谷歌正在用的”（谷歌工程师在 Kubernetes 上正做着很重大的工作！但是我认为重要的仍然是研究架构，并确保它对你的组织有意义）。
我肯定不是 Kubernetes 网络方面的专家，但是我在配置 Kubernetes 网络时遇到了一些问题，并且比以前更加了解 Kubernetes 网络了。
### 运维联网软件是很难的
在这里，我并不讨论有关运维物理网络的话题（对于它我不懂），而是讨论关于如何让像 DNS 服务、负载均衡以及代理这样的软件正常工作方面的内容。
我在一个负责很多网络基础设施的团队工作过一年时间，并且因此学到了一些运维网络基础设施的知识！（显然我还有很多的知识需要继续学习）在我们开始之前有三个整体看法：
* 联网软件经常重度依赖 Linux 内核。因此除了正确配置软件之外，你还需要确保许多不同的系统控制（`sysctl`）配置正确，而一个错误配置的系统控制就很容易让你处于“一切都很好”和“到处都出问题”的差别中。
* 联网需求会随时间而发生变化（比如，你的 DNS 查询或许比上一年多了五倍！或者你的 DNS 服务器突然开始返回 TCP 协议的 DNS 响应而不是 UDP 的，它们是完全不同的内核负载！）。这意味着之前正常工作的软件突然开始出现问题。
* 修复一个生产网络的问题，你必须有足够的经验。（例如，看这篇 [由 Sophie Haskins 写的关于 kube-dns 问题调试的文章](http://blog.sophaskins.net/blog/misadventures-with-kube-dns/)）我在网络调试方面比以前进步多了，但那也是我花费了大量时间研究 Linux 网络知识之后的事了。
我距离成为一名网络运维专家还差得很远，但是我认为以下几点很重要：
1. 对生产网络的基础设施做重要的更改是很难得的（因为它会产生巨大的混乱）
2. 当你对网络基础设施做重大更改时，真的应该仔细考虑如果新网络基础设施失败该如何处理
3. 是否有很多人都能理解你的网络配置
切换到 Kubernetes 显然是个非常大的更改！因此，我们来讨论一下可能会导致错误的地方！
### Kubernetes 网络组件
在本文中我们将要讨论的 Kubernetes 网络组件有：
* <ruby> 覆盖网络 <rt> overlay network </rt></ruby>的后端（像 flannel/calico/weave 网络/romana）
* `kube-dns`
* `kube-proxy`
* 入站控制器 / 负载均衡器
* `kubelet`
如果你打算配置 HTTP 服务，或许这些你都会用到。这些组件中的大部分我都不会用到，但是我尽可能去理解它们，因此，本文将涉及它们有关的内容。
### 最简化的方式：为所有容器使用宿主机网络
让我们从你能做到的最简单的东西开始。这并不能让你在 Kubernetes 中运行 HTTP 服务。我认为它是非常安全的，因为在这里面可以让你动的东西很少。
如果你为所有容器使用宿主机网络，我认为需要你去做的全部事情仅有：
1. 配置 kubelet，以便于容器内部正确配置 DNS
2. 没了，就这些！
如果你为每个 pod 直接使用宿主机网络，那就不需要 kube-dns 或者 kube-proxy 了。你都不需要一个作为基础的覆盖网络。
这种配置方式中，你的 pod 们都可以连接到外部网络（同样的方式，你的宿主机上的任何进程都可以与外部网络对话），但外部网络不能连接到你的 pod 们。
这并不是最重要的（我认为大多数人想在 Kubernetes 中运行 HTTP 服务并与这些服务进行真实的通讯），但我认为有趣的是，从某种程度上来说，网络的复杂性并不是绝对需要的，并且有时候你不用这么复杂的网络就可以实现你的需要。如果可以的话，尽可能地避免让网络过于复杂。
### 运维一个覆盖网络
我们将要讨论的第一个网络组件是有关覆盖网络的。Kubernetes 假设每个 pod 都有一个 IP 地址，这样你就可以与那个 pod 中的服务进行通讯了。我在说到“覆盖网络”这个词时，指的就是这个意思（“让你通过它的 IP 地址指向到 pod 的系统）。
所有其它的 Kubernetes 网络的东西都依赖正确工作的覆盖网络。更多关于它的内容，你可以读 [这里的 kubernetes 网络模型](https://kubernetes.io/docs/concepts/cluster-administration/networking/#kubernetes-model)。
Kelsey Hightower 在 [kubernetes 艰难之路](https://github.com/kelseyhightower/kubernetes-the-hard-way/blob/master/docs/11-pod-network-routes.md) 中描述的方式看起来似乎很好，但是，事实上它的作法在超过 50 个节点的 AWS 上是行不通的，因此，我不打算讨论它了。
有许多覆盖网络后端（calico、flannel、weaveworks、romana）并且规划非常混乱。就我的观点来看，我认为一个覆盖网络有 2 个职责：
1. 确保你的 pod 能够发送网络请求到外部的集群
2. 保持一个到子网络的稳定的节点映射，并且保持集群中每个节点都可以使用那个映射得以更新。当添加和删除节点时，能够做出正确的反应。
Okay! 因此！你的覆盖网络可能会出现的问题是什么呢？
* 覆盖网络负责设置 iptables 规则（最基本的是 `iptables -A -t nat POSTROUTING -s $SUBNET -j MASQUERADE`），以确保那个容器能够向 Kubernetes 之外发出网络请求。如果在这个规则上有错误，你的容器就不能连接到外部网络。这并不很难（它只是几条 iptables 规则而已），但是它非常重要。我发起了一个 [拉取请求](https://github.com/coreos/flannel/pull/808)，因为我想确保它有很好的弹性。
* 添加或者删除节点时可能会有错误。我们使用 `flannel hostgw` 后端，我们开始使用它的时候，节点删除功能 [尚未开始工作](https://github.com/coreos/flannel/pull/803)。
* 你的覆盖网络或许依赖一个分布式数据库（etcd）。如果那个数据库发生什么问题，这将导致覆盖网络发生问题。例如，<https://github.com/coreos/flannel/issues/610> 上说，如果在你的 `flannel etcd` 集群上丢失了数据，最后的结果将是在容器中网络连接会丢失。（现在这个问题已经被修复了）
* 你升级 Docker 以及其它东西导致的崩溃
* 还有更多的其它的可能性！
我在这里主要讨论的是过去发生在 Flannel 中的问题，但是我并不是要承诺不去使用 Flannel —— 事实上我很喜欢 Flannel，因为我觉得它很简单（比如，类似 [vxlan 在后端这一块的部分](https://github.com/coreos/flannel/tree/master/backend/vxlan) 只有 500 行代码），对我来说，通过代码来找出问题的根源成为了可能。并且很显然，它在不断地改进。他们在审查拉取请求方面做的很好。
到目前为止，我运维覆盖网络的方法是：
* 学习它的工作原理的详细内容以及如何去调试它（比如，Flannel 用于创建路由的 hostgw 网络后端，因此，你只需要使用 `sudo ip route list` 命令去查看它是否正确即可）
* 如果需要的话，维护一个内部构建版本，这样打补丁比较容易
* 有问题时，向上游贡献补丁
我认为去遍历所有已合并的拉取请求以及过去已修复的 bug 清单真的是非常有帮助的 —— 这需要花费一些时间，但这是得到一个其它人遇到的各种问题的清单的好方法。
对其他人来说，他们的覆盖网络可能工作的很好，但是我并不能从中得到任何经验，并且我也曾听说过其他人报告类似的问题。如果你有一个类似配置的覆盖网络：a) 在 AWS 上并且 b) 在多于 50-100 节点上运行，我想知道你运维这样的一个网络有多大的把握。
### 运维 kube-proxy 和 kube-dns？
现在，我有一些关于运维覆盖网络的想法，我们来讨论一下。
这个标题的最后面有一个问号，那是因为我并没有真的去运维过。在这里我还有更多的问题要问答。
这里的 Kubernetes 服务是如何工作的！一个服务是一群 pod 们，它们中的每个都有自己的 IP 地址（像 10.1.0.3、10.2.3.5、10.3.5.6 这样）
1. 每个 Kubernetes 服务有一个 IP 地址（像 10.23.1.2 这样）
2. `kube-dns` 去解析 Kubernetes 服务 DNS 名字为 IP 地址（因此，my-svc.my-namespace.svc.cluster.local 可能映射到 10.23.1.2 上）
3. `kube-proxy` 配置 `iptables` 规则是为了在它们之间随机进行均衡负载。Kube-proxy 也有一个用户空间的轮询负载均衡器，但是在我的印象中，他们并不推荐使用它。
因此，当你发出一个请求到 `my-svc.my-namespace.svc.cluster.local` 时，它将解析为 10.23.1.2，然后，在你本地主机上的 `iptables` 规则（由 kube-proxy 生成）将随机重定向到 10.1.0.3 或者 10.2.3.5 或者 10.3.5.6 中的一个上。
在这个过程中我能想像出的可能出问题的地方：
* `kube-dns` 配置错误
* `kube-proxy` 挂了，以致于你的 `iptables` 规则没有得以更新
* 维护大量的 `iptables` 规则相关的一些问题
我们来讨论一下 `iptables` 规则，因为创建大量的 `iptables` 规则是我以前从没有听过的事情！
kube-proxy 像如下这样为每个目标主机创建一个 `iptables` 规则：这些规则来自 [这里](https://github.com/kubernetes/kubernetes/issues/37932)）
```
-A KUBE-SVC-LI77LBOOMGYET5US -m comment --comment "default/showreadiness:showreadiness" -m statistic --mode random --probability 0.20000000019 -j KUBE-SEP-E4QKA7SLJRFZZ2DD[b][c]
-A KUBE-SVC-LI77LBOOMGYET5US -m comment --comment "default/showreadiness:showreadiness" -m statistic --mode random --probability 0.25000000000 -j KUBE-SEP-LZ7EGMG4DRXMY26H
-A KUBE-SVC-LI77LBOOMGYET5US -m comment --comment "default/showreadiness:showreadiness" -m statistic --mode random --probability 0.33332999982 -j KUBE-SEP-RKIFTWKKG3OHTTMI
-A KUBE-SVC-LI77LBOOMGYET5US -m comment --comment "default/showreadiness:showreadiness" -m statistic --mode random --probability 0.50000000000 -j KUBE-SEP-CGDKBCNM24SZWCMS
-A KUBE-SVC-LI77LBOOMGYET5US -m comment --comment "default/showreadiness:showreadiness" -j KUBE-SEP-RI4SRNQQXWSTGE2Y
```
因此，kube-proxy 创建了许多 `iptables` 规则。它们都是什么意思？它对我的网络有什么样的影响？这里有一个来自华为的非常好的演讲，它叫做 [支持 50,000 个服务的可伸缩 Kubernetes](https://www.youtube.com/watch?v=4-pawkiazEg)，它说如果在你的 Kubernetes 集群中有 5,000 服务，增加一个新规则，将需要 **11 分钟**。如果这种事情发生在真实的集群中，我认为这将是一件非常糟糕的事情。
在我的集群中肯定不会有 5,000 个服务，但是 5,000 并不是那么大的一个数字。为解决这个问题，他们给出的解决方案是 kube-proxy 用 IPVS 来替换这个 `iptables` 后端，IPVS 是存在于 Linux 内核中的一个负载均衡器。
看起来，像 kube-proxy 正趋向于使用各种基于 Linux 内核的负载均衡器。我认为这只是一定程度上是这样，因为他们支持 UDP 负载均衡，而其它类型的负载均衡器（像 HAProxy）并不支持 UDP 负载均衡。
但是，我觉得使用 HAProxy 更舒服！它能够用于去替换 kube-proxy！我用谷歌搜索了一下，然后发现了这个 [thread on kubernetes-sig-network](https://groups.google.com/forum/#!topic/kubernetes-sig-network/3NlBVbTUUU0)，它说：
>
> kube-proxy 是很难用的，我们在生产系统中使用它近一年了，它在大部分的时间都表现的很好，但是，随着我们集群中的服务越来越多，我们发现它的排错和维护工作越来越难。在我们的团队中没有 iptables 方面的专家，我们只有 HAProxy & LVS 方面的专家，由于我们已经使用它们好几年了，因此我们决定使用一个中心化的 HAProxy 去替换分布式的代理。我觉得这可能会对在 Kubernetes 中使用 HAProxy 的其他人有用，因此，我们更新了这个项目，并将它开源：<https://github.com/AdoHe/kube2haproxy>。如果你发现它有用，你可以去看一看、试一试。
>
>
>
因此，那是一个有趣的选择！我在这里确实没有答案，但是，有一些想法：
* 负载均衡器是很复杂的
* DNS 也很复杂
* 如果你有运维某种类型的负载均衡器（比如 HAProxy）的经验，与其使用一个全新的负载均衡器（比如 kube-proxy），还不如做一些额外的工作去使用你熟悉的那个来替换，或许更有意义。
* 我一直在考虑，我们希望在什么地方能够完全使用 kube-proxy 或者 kube-dns —— 我认为，最好是只在 Envoy 上投入，并且在负载均衡&服务发现上完全依赖 Envoy 来做。因此，你只需要将 Envoy 运维好就可以了。
正如你所看到的，我在关于如何运维 Kubernetes 中的内部代理方面的思路还是很混乱的，并且我也没有使用它们的太多经验。总体上来说，kube-proxy 和 kube-dns 还是很好的，也能够很好地工作，但是我仍然认为应该去考虑使用它们可能产生的一些问题（例如，”你不能有超出 5000 的 Kubernetes 服务“）。
### 入口
如果你正在运行着一个 Kubernetes 集群，那么到目前为止，很有可能的是，你事实上需要 HTTP 请求去进入到你的集群中。这篇博客已经太长了，并且关于入口我知道的也不多，因此，我们将不讨论关于入口的内容。
### 有用的链接
几个有用的链接，总结如下：
* [Kubernetes 网络模型](https://kubernetes.io/docs/concepts/cluster-administration/networking/#kubernetes-model)
* GKE 网络是如何工作的：<https://www.youtube.com/watch?v=y2bhV81MfKQ>
* 上述的有关 `kube-proxy` 上性能的讨论：<https://www.youtube.com/watch?v=4-pawkiazEg>
### 我认为网络运维很重要
我对 Kubernetes 的所有这些联网软件的感觉是，它们都仍然是非常新的，并且我并不能确定我们（作为一个社区）真的知道如何去把它们运维好。这让我作为一个操作者感到很焦虑，因为我真的想让我的网络运行的很好！:) 而且我觉得作为一个组织，运行你自己的 Kubernetes 集群需要相当大的投入，以确保你理解所有的代码片段，这样当它们出现问题时你可以去修复它们。这不是一件坏事，它只是一个事而已。
我现在的计划是，继续不断地学习关于它们都是如何工作的，以尽可能多地减少对我动过的那些部分的担忧。
一如继往，我希望这篇文章对你有帮助，并且如果我在这篇文章中有任何的错误，我非常喜欢你告诉我。
---
via: <https://jvns.ca/blog/2017/10/10/operating-a-kubernetes-network/>
作者：[Julia Evans](https://jvns.ca/about) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
到底什么是区块链
|
Vegard Nordahl, Meghana Rao
|
https://www.myblockchainblog.com/blog/what-the-hell-is-blockchain
|
虽然区块链通常被认为是计算机技术的进步，但它更容易被理解为会计的进步。
|
/data/attachment/album/201809/11/222752x21h0jffyr25u6uz.jpg.thumb.jpg
|
/data/attachment/album/201809/11/222752x21h0jffyr25u6uz.jpg
| true | false | true |
jasminepeng
|
jasminepeng
|
wxy
| false |
[
"区块链"
] |
区块链
|
{
"viewnum": 4980,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10036,
"displayorder": 0
}
] |
虽然区块链通常被认为是计算机技术的进步，但它更容易被理解为会计的进步。
| 2018-09-11T22:29:40 | 2018-09-11T22:29:40 | 10,004 |
/article-10004-1.html
|
>
> 编者按：本系列区块链文章改编自网络文章，本文主要基于 Vegard Nordahl & Meghana Rao 的[文章](https://www.myblockchainblog.com/blog/what-the-hell-is-blockchain)，并补充修订了部分内容。
>
>
>
### 我们为什么要写这个博客？
想象一下，你穿越到 1990 年代早期。当时，互联网还处于起步阶段，老百姓几乎没有理解它是如何运作的。
1993 年，全球互联网用户总数约为 1400 万，整个互联网由大约 130 个网站组成（[ourworldindata.org](http://ourworldindata.org)）。大多数人都听说过互联网，但是对于绝大多数人来说，还很难看到它的前景。
1995 年左右，风险投资开始意识到万维网的巨大潜力，互联网从默默无闻变为主流。数百万美元投入到初创公司中，通常只包括一小部分程序员和一个涉及互联网的想法。尽管如此，人们对互联网还是持怀疑态度，大规模采用似乎还远未确定。
“我预测互联网将很快成为超新星，并在 1996 年灾难性地崩溃。”
—— 以太网发明者 Robert Metcalfe，InfoWorld，1995 年
“事实上，在线数据库不会取代你的日报，光盘不会可以取代一个称职的老师，计算机网络也不会改变政府的工作方式。”
- 新闻周刊，1995年
一年后，互联网拥有了 7500 万用户。到 1999 年，它已在全球范围内增长到 2.8 亿用户。
两年后 Robert Metcalfe 在万维网大会上不得不“吃掉他的话”，他将他的专栏副本与一些水混合，在观众面前吃下去（[wired](https://www.wired.com/1998/11/metcalfe/)）。而新闻周刊于 2012 年停止了纸质印刷，改为纯在线方式发售……
那么， Robert Metcalfe 和新闻周刊在互联网趋势的判断上出了什么问题呢？我们认为，他们严重低估了互联网减少低效从而提高人类创造价值的能力。互联网现在渗透到我们生活的各个方面的真正原因是它使得个人和企业的效率大大提高了。
今天，由于区块链这个技术创新的出现，人类又一次站在一个潜在的效率飞跃的十字路口。风投已开始意识到区块链的巨大潜力，向初创公司投入大量资金，这些公司通常只包括一小组程序员和一个涉及区块链的想法（[weusecoins.com](https://www.weusecoins.com/en/venture-capital-investments-in-bitcoin-and-blockchain-companies/)）。与此同时，老百姓对区块链的运作方式几乎没有了解。
本博客试图向小白们介绍区块链，让他们了解这项技术并教他们如何成为参与者。在本博客的过程中，我们将深入探讨区块链的一些技术方面，探索其用例，分析不同的区块链，为初学者提供分步指南。
### 区块链，一场会计革命
虽然区块链通常被认为是计算机技术的进步，但它更容易被理解为会计的进步。本质上讲，会计的任务是追踪交易和价值所有权。仔细思考的话，你会发现所有权是一种模糊的概念。所有权不是物品的固有属性。相反，所有权完全由共识决定。你可以在一个物体上写下你的名字或在房产上插上你自己的旗帜，但你必须能说服你社会中的其他人同意这是真正属于你的资产。既然所有权不是内在属性，我们如何在任何时间确定所有权？我们如何建立一个系统来确保所有权信息是安全的，并且不会被恶意用户改变？
这不是一个简单的问题，随着我们的社会变得越来越复杂，人类发明了越来越聪明的解决方式。在现代社会，确定和记录所有权的方式因资产类型而异，但通常可归结为以下内容。
>
> 当前的所有权跟踪系统
> 当前，物品、资产或创意的所有权由我们的法律系统决定，通常涉及书面或数字的所有权记录（例如，土地所有权、收据、版权文件、专利等）。当两个非信任方之间发生所有权转让时，我们依靠银行或政府组织等中介机构来获取信任、真实性和确定性。对于数字或非实物资产（如货币、股票、知识产权或数字媒体）尤其如此。如果两个人都声称对同一资产拥有所有权，或者记录的合法性存在争议，则通过法院或法庭来解决争议，确定所有权。
>
>
>
我们目前的所有权跟踪系统复杂、效率低、不是特别可靠，而且往往不是很透明。这包括让中间人参与并使文档难以伪造/复制。这就是为什么许多国家要求您支付印花税或其他税款，以使结婚证书和土地所有权等文件具有法律约束力和可执行性。这也是为什么需要 3 天才能汇款给国外的亲戚。中间人必须确保资金进入和离开正确的账户，并确保适当的记录完整无缺。所有信息记账的情况都是如此，它们的准确性至关重要，例如支付和货币系统、资产管理、监管合规和审计、房地产、记录管理、身份管理、投票、税收等。
这就是区块链技术的用武之地。
区块链本质上是一种会计工具，它大大简化了这一过程，并提供了一个不依赖中介的记录保存系统，而且它具有以下特点：
* 快速高效
* 不受伪造/黑客攻击
* 可靠
* 不可更改（一旦信息被锁定，就无法更改）
* 透明
* 不需要双方之间的信任
### 区块链的内部运作
简而言之，区块链是一个数据库，它包含不断增长的安全加密信息链接块，这些信息块通过独立的分散节点网络进行复制和分发。
是不是有点拗口？下面简单介绍下。
在区块链术语中，“<ruby> 块 <rt> block </rt></ruby>”只是被认为同时发生的信息的集合。想象它的最简单方法是将单个块想象为一个电子表格。
电子表格中的每一行都包含一条信息，例如交易信息，例如“Vega 向 Meg 发送 4 美元”。最终，电子表格块“完成”并链接到链中的前一个块。
然后，新添加的块被广播到网络中的每个节点。节点是用于区块链的计算机。
结果是包含数百万行信息的长链电子表格，复制并存储在不同的节点上。由于任何人都可以将计算机设置为节点，因此您最终会在全球范围内建立庞大的公有计算机网络，这些都有助于整个区块链的健康和安全。
让我们看一个具体的例子来准确理解信息如何通过区块链传输。Joe 想要使用世界上最知名的区块链 —— 比特币区块链将 $5 发送给 Jane。要做到这一点，Joe 所要做的就是在他的计算机上写出这笔交易的代码并将其广播到比特币区块链网络。
随着区块链网络上的计算机收到此消息，它将进入一个称为<ruby> 未确认事务云 <rt> unconfirmed transaction cloud </rt></ruby>的特殊位置。
区块链网络中的每台计算机都在持续监听未确认事务云，尝试以解决特殊谜题的方式对消息进行排序（之后会详细介绍）。
当计算机设法找到解决特殊谜题的方法时，他们将其广播到区块链网络的其余部分，并获得对首个解决谜题的计算机的奖品。
然后，未确认事务云中的消息变成一个整齐的块（电子表格），并且每个计算机在验证该解决方案确实解决了特殊谜题之后，将此块附加到区块链。
每个计算机节点都将整个区块链存储在其硬盘驱动器上，并且可以独立于区块链网络上的其他节点来验证传入的消息和块。整个系统去中心化，没有单点故障。
这基本上就是比特币区块链的工作原理：
1. 用户将交易广播到区块链网络
2. 计算机节点以解决特殊谜题的方式竞争，获得打包事务权
3. 当节点可以正确打包事务时，它们会将解决方案广播到网络上的所有其他节点
4. 每个节点独立地验证解决方案
5. 如果解决方案有效并且块中仅包含可信事务，每个节点就独立地将新块附加到区块链
与传统会计系统相比，区块链的优点是：
* 没有单点故障：如果一台计算机突然关闭或被黑客入侵，不会打扰或损害网络的其余部分。其余的计算机将继续向区块链添加电子表格块。
* 去中心化系统：基于区块链技术的所有权记录不受某个实体或组织的控制。
* 超级高效：在验证传入消息时不涉及人工。建立信任不需要中间人或中间人。一切都是通过计算机代码完成的，通过独立的公有计算机网络实现完整性。
* 完全透明性：每个电子表格上的每一行都存储在网络上的每个节点上。因此，区块链中的所有信息都是公开的，如果怀疑存在不法行为，任何人都可以对其进行检查和审查。
* <ruby> 非实名 <rt> pseudo-anonymous </rt></ruby>：区块链中不存储任何姓名或个人信息。交易和账户余额是公开的；换句话说，非实名是指每个人在区块链上有一个和真实身份无关的虚拟身份，但是这个虚拟身份做的所有事情都是透明的。
### 区块链安全
上面这些可能听起来很诱人，但您可能仍有疑问。
世界上存在着无数超级聪明的恶意黑客，这个方案真的安全吗？
区块链公开存储，会有严重的隐私问题吗？
可以在区块链中使用的加密保护机制中找到这两个问题的答案。要了解破解区块链多么困难，您必须了解一些基础技术。大多数区块链使用两种加密技术的组合：加密哈希函数和数字签名，实现两个目标：
* 确保块是不可变的。也就是说，确保每个块在区块链中的特定位置，并且改变顺序或改变块的内容是不可能的。
* 由整个区块链网络验证广播的交易确实来自帐户的私钥持有者。
这些保护机制的内部工作非常有趣，将在之后详细介绍。
许多人认为网络安全本质上是不安全的，如果有足够的时间和激励，超级聪明的恶意黑客将总能找到窃取您信息的方法。
但事实并非如此。绝大多数区块链中使用的加密系统从未被破解。专家们普遍认为，目前的最佳加密方法对于普通计算机是不可击穿的。如果有人真的找到了方法来破解这些系统，区块链程序也无需太担心，因为我们的整个金融系统目前使用完全相同的加密技术。
以比特币为例来看区块链技术的安全性。比特币是世界上第一个也是目前最大的区块链加密货币，于 2009 年 1 月投入使用。从那时起，它的市值已经增长到 400 多亿美元（编者注：到2018年9月，市值已达一千多亿美元），每天大约有 300,000 个比特币交易。尽管如此，基本的比特币算法并没有出现过一次破坏。不过，对于这个行业来说，发生过多次比特币交易网站被黑客入侵。然而，比特币本身从未被黑客入侵，并且继续保持 100％ 的跟踪记录，其表现完全符合其创建者的预期。
这并不是说比特币的处理没有风险。要正确处理任何加密货币，您需要采取一些预防措施，以确保那些超级聪明的恶意黑客无法访问您的帐户。区块链安全性将成为本系列的关键主题之一，因为我们坚信，赋予人们安全和自信地使用区块链技术的能力对于实现该技术的大规模采用至关重要。
随着区块链技术的成熟，我们希望您将来加入我们。我们确信这项技术将改变世界，也很高兴能够在这个早期阶段参与这一旅程。
所以，无论你以前从未听说过区块链，你是一个想要了解更多技术的爱好者，或者你是寻找新机会的投资者，你来对了地方。我们将努力定期更新我们的系列文章，并提供关于区块链技术各方面的细致，公正的观点。
你喜欢这篇博文吗？我们很乐意在下面的留言板上收到您的来信！如果您在我们的内容中发现任何错误或错误，请随时告诉我们，我们会及时更正。我们的下一篇文章将简要介绍区块链和比特币的历史。希望能在那里见到你！
---
via: <https://www.myblockchainblog.com/blog/what-the-hell-is-blockchain>
作者：[Vegard Nordahl & Meghana Rao](https://www.myblockchainblog.com/?author=57ca44c0bebafb5698fc5e7d) 选题：[jasminepeng](https://github.com/jasminepeng) 译者：[jasminepeng](https://github.com/jasminepeng) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](/article-9986-1.html) 荣誉推出
|
差异文件（diff）和补丁文件（patch）简介
|
Phil Estes
|
https://opensource.com/article/18/8/diffs-patches
|
这篇文章介绍差异文件（diff）和补丁文件（patch），以及它们如何在开源项目中使用的例子。
|
/data/attachment/album/201809/12/104022bbzxcgxgkcpcgj4g.jpg.thumb.jpg
|
/data/attachment/album/201809/12/104022bbzxcgxgkcpcgj4g.jpg
| true | false | true |
lujun9972
|
DavidChenLiang
|
wxy
| false |
[
"补丁",
"版本控制",
"git"
] |
软件开发
|
{
"viewnum": 8114,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这篇文章介绍差异文件（diff）和补丁文件（patch），以及它们如何在开源项目中使用的例子。
| 2018-09-12T10:40:50 | 2018-09-12T10:40:50 | 10,005 |
/article-10005-1.html
|
>
> 这篇文章介绍<ruby> 差异文件 <rt> diff </rt></ruby>和<ruby> 补丁文件 <rt> patch </rt></ruby>，以及它们如何在开源项目中使用的例子。
>
>
>
如果你曾有机会在一个使用分布式开发模型的大型代码库上工作过，你就应该听说过类似下面的话，“Sue 刚发过来一个<ruby> 补丁 <rt> patch </rt></ruby>”，“Rajiv 正在<ruby> 签出 <rt> checking out </rt></ruby><ruby> 差异 <rt> diff </rt></ruby>”, 可能这些词（补丁、差异文件）对你而言很陌生，而你确定很想搞懂他们到底指什么。开源软件对上述提到的名词有很大的贡献，作为大型项目从 Apache web 服务器到 Linux 内核的开发模型，“基于补丁文件的开发” 这一模式贯穿了上述项目的始终。实际上，你可能不知道 Apache 的名字就来自“一系列的代码补丁”（LCTT 译注：Apache 英文发音和补丁的英文 patch 相似)，它们被一一收集起来并针对原来的 [NCSA HTTPd server source code](https://github.com/TooDumbForAName/ncsa-httpd) 进行了修订。
你可能认为这只不过是些逸闻，但是一份早期的 [Apache 网站的存档中](https://web.archive.org/web/19970615081902/http:/www.apache.org/info.html) 声称 Apache 的名字就是来自于最早的“补丁”集合；即“<ruby> 打了补丁的 <rt> APAtCHy </rt></ruby>”服务器，简化为 Apache。
好了，言归正传，程序员嘴里说的“差异”和“补丁”到底是什么？
首先，在这篇文章里，我们可以认为这两个术语都指向同一个概念。“diff” 是 ”difference“ 的简写；Unix 下的同名工具程序 `diff`剖析了一个或多个文件之间的“差异”。下面我们会看到 `diff` 的例子:
一个“补丁”指的是文件之间一系列差异，这些差异能被 Unix 的 `diff` 程序应用在源代码树上。我们能使用 `diff` 工具来创建“差异”（或“补丁”），然后使用该工具将它们 “打” 在一个没有这个补丁的同样的源代码版本上。此外，（我又要开始跑题说些历史轶事了……），“补丁” 这个词真的指在计算机的早期使用打卡机的时候，用来覆盖在打孔纸带上来对软件进行修改的覆盖纸，那个时代打孔纸带就是在计算机处理器上运行的程序。下面来自 [维基页面](https://en.wikipedia.org/wiki/Patch_(computing)) 的这张图真切的描绘了最初的“打补丁”这个词的出处:
现在你对补丁和差异就了一个基本的概念，让我们来看看软件开发者是怎么使用这些工具的。如果你还没有使用过类似于 [Git](https://git-scm.com/) 或 [subversion](https://subversion.apache.org/) 这样的源代码版本控制工具的话，我将会一步步展示最流行的软件项目是怎么使用它们的。如果你将一个软件的生命周期看成是一条时间线的话，你就能看见这个软件的点滴变化，比如在何时源代码加上了一个功能，在何时源代码修复了一个功能缺陷。我们称这些改变的点为“<ruby> 提交 <rt> commit </rt></ruby>”，“提交”这个词被当今最流行的源代码版本管理工具 Git 所使用，当你想检查在一个提交前后的代码变化的话，（或者在许多个提交之间的代码变化），你都可以使用工具来观察文件差异。
如果你同样在使用 Git 开发软件的话，你可以在你的本地开发环境做些希望交给别的开发者的提交，以添加到他们的源代码树中。为了给别的开发者你的提交，一个方法就是创建一个你本地文件的差异文件，然后将这个“补丁”发送给和你工作在同一个源代码树的别的开发者。别的开发者在“打”了你的补丁之后，就能看到在你的代码变树上的变化。
### Linux、Git 和 GitHub
这种分享补丁的开发模型正是现今 Linux 内核社区如何处理内核修改提议而采用的模型。如果你有机会浏览任何一个主流的 Linux 内核邮件列表 —— 主要是 [LKML](https://lkml.org/)，也包括 [linux-containers](https://lists.linuxfoundation.org/pipermail/containers/)、[fs-devel](https://patchwork.kernel.org/project/linux-fsdevel/list/)、[Netdev](https://www.spinics.net/lists/netdev/) 等等，你能看到很多开发者会贴出他们想让其他内核开发者审核、测试或者合入 Linux 官方 Git 代码树某个位置的补丁。当然，讨论 Git 不在这篇文章范围之内（Git 是由 Linus Torvalds 开发的源代码控制系统，它支持分布式开发模型以及允许独立于主要代码仓库的补丁包，这些补丁包能被推送或拉取到不同的源代码树上，并遵守这些代码树各自的开发流程。）
在继续我们的话题之前，我们当然不能忽略和补丁和差异这个概念相关的最流行的服务：[GitHub](https://github.com/)。从它的名字就能猜想出 GitHub 是基于 Git 的，而且它还围绕着 Git 对分布式开源代码开发模型提供了基于 Web 和 API 的工作流管理。（LCTT 译注：即<ruby> 拉取请求 <rt> Pull Request </rt></ruby>）。在 GitHub 上，分享补丁的方式不是像 Linux 内核社区那样通过邮件列表，而是通过创建一个 **拉取请求** 。当你提交你自己的源代码树的改动时，你能通过创建一个针对软件项目的共享仓库的“拉取请求”来分享你的代码改动（LCTT 译注：即核心开发者维护一个主仓库，开发者去“<ruby> 复刻 <rt> fork </rt></ruby>”这个仓库，待各自的提交后再创建针对这个主仓库的拉取请求，所有的拉取请求由主仓库的核心开发者批准后才能合入主代码库。）GitHub 被当今很多活跃的开源社区所采用，如 [Kubernetes](https://kubernetes.io/)、[Docker](https://www.docker.com/)、[容器网络接口 (CNI)](https://github.com/containernetworking/cni)、[Istio](https://istio.io/) 等等。在 GitHub 的世界里，用户会倾向于使用基于 Web 页面的方式来审核一个拉取请求里的补丁或差异，你也可以直接访问原始的补丁并在命令行上直接使用它们。
### 该说点干货了
我们前面已经讲了在流行的开源社区里是怎么应用补丁和差异的，现在看看一些例子。
第一个例子包括一个源代码树的两个不同副本，其中一个有代码改动，我们想用 `diff` 来看看这些改动是什么。这个例子里，我们想看的是“<ruby> 合并格式 <rt> unified </rt></ruby>”的补丁，这是现在软件开发世界里最通用的格式。如果想知道更详细参数的用法以及如何生成差异文件，请参考 `diff` 手册。原始的代码在 `sources-orig` 目录，而改动后的代码在 `sources-fixed` 目录。如果要在你的命令行上用“合并格式”来展示补丁，请运行如下命令。（LCTT 译注：参数 `-N` 代表如果比较的文件不存在，则认为是个空文件， `-a` 代表将所有文件都作为文本文件对待，`-u` 代表使用合并格式并输出上下文，`-r` 代表递归比较目录）
```
$ diff -Naur sources-orig/ sources-fixed/
```
……下面是 `diff` 命令的输出：
```
diff -Naur sources-orig/officespace/interest.go sources-fixed/officespace/interest.go
--- sources-orig/officespace/interest.go 2018-08-10 16:39:11.000000000 -0400
+++ sources-fixed/officespace/interest.go 2018-08-10 16:39:40.000000000 -0400
@@ -11,15 +11,13 @@
InterestRate float64
}
+// compute the rounded interest for a transaction
func computeInterest(acct *Account, t Transaction) float64 {
interest := t.Amount * t.InterestRate
roundedInterest := math.Floor(interest*100) / 100.0
remainingInterest := interest - roundedInterest
- // a little extra..
- remainingInterest *= 1000
-
// Save the remaining interest into an account we control:
acct.Balance = acct.Balance + remainingInterest
```
最开始几行 `diff` 命令的输出可以这样解释：三个 `---` 显示了原来文件的名字；任何在原文件（LCTT 译注：不是源文件）里存在而在新文件里不存在的行将会用前缀 `-`，用来表示这些行被从源代码里“减去”了。而 `+++` 表示的则相反：在新文件里被加上的行会被放上前缀 `+`，表示这是在新文件里被“加上”的行。补丁文件中的每一个补丁“块”（用 `@@` 作为前缀的的部分）都有上下文的行号，这能帮助补丁工具（或其它处理器）知道在代码的哪里应用这个补丁块。你能看到我们已经修改了“Office Space”这部电影里提到的那个函数（移除了三行并加上了一行代码注释），电影里那个有点贪心的工程师可是偷偷的在计算利息的函数里加了点“料”哦。（LCTT译注：剧情详情请见电影 [https://movie.douban.com/subject/1296424/）](https://movie.douban.com/subject/1296424/%EF%BC%89)
如果你想找人来测试你的代码改动，你可以将差异保存到一个补丁里：
```
$ diff -Naur sources-orig/ sources-fixed/ >myfixes.patch
```
现在你有补丁 `myfixes.patch` 了，你能把它分享给别的开发者，他们可以将这个补丁打在他们自己的源代码树上从而得到和你一样的代码并测试他们。如果一个开发者的当前工作目录就是他的源代码树的根的话，他可以用下面的命令来打补丁：
```
$ patch -p1 < ../myfixes.patch
patching file officespace/interest.go
```
现在这个开发者的源代码树已经打好补丁并准备好构建和测试文件的修改了。那么如果这个开发者在打补丁之前已经改动过了怎么办？只要这些改动没有直接冲突（LCTT 译注：比如改在同一行上），补丁工具就能自动的合并代码的改动。例如下面的interest.go 文件，它有其它几处改动，然后它想打上 `myfixes.patch` 这个补丁：
```
$ patch -p1 < ../myfixes.patch
patching file officespace/interest.go
Hunk #1 succeeded at 26 (offset 15 lines).
```
在这个例子中，补丁警告说代码改动并不在文件原来的地方而是偏移了 15 行。如果你文件改动的很厉害，补丁可能干脆说找不到要应用的地方，还好补丁程序提供了提供了打开“模糊”匹配的选项（这个选项在文档里有预置的警告信息，对其讲解已经超出了本文的范围）。
如果你使用 Git 或者 GitHub 的话，你可能不会直接使用补丁或差异。Git 已经内置了这些功能，你能使用这些功能和共享一个源代码树的其他开发者交互，拉取或合并代码。Git 一个比较相近的功能是可以使用 `git diff` 来对你的本地代码树生成全局差异，又或者对你的任意两次”引用“（可能是一个代表提交的数字，或一个标记或分支的名字，等等）做全局补丁。你甚至能简单的用管道将 `git diff` 的输出到一个文件里（这个文件必须严格符合将要被使用它的程序的输入要求），然后将这个文件交给一个并不使用 Git 的开发者应用到他的代码上。当然，GitHub 把这些功能放到了 Web 上，你能直接在 Web 页面上查看一个拉取请求的文件变动。在 Web 上你能看到所展示的合并差异，GitHub 还允许你将这些代码改动下载为原始的补丁文件。
### 总结
好了，你已经学到了”差异“和”补丁“是什么，以及在 Unix/Linux 上怎么使用命令行工具和它们交互。除非你还在像 Linux 内核开发这样的项目中工作而使用完全基于补丁文件的开发方式，你应该会主要通过你的源代码控制系统（如 Git）来使用补丁。但熟悉像 GitHub 这样的高级别工具的技术背景和技术底层对你的工作也是大有裨益的。谁知道会不会有一天你需要和一个来自 Linux 世界邮件列表的补丁包打交道呢？
---
via: <https://opensource.com/article/18/8/diffs-patches>
作者：[Phil Estes](https://opensource.com/users/estesp) 选题：[lujun9972](https://github.com/lujun9972) 译者：[David Chen](https://github.com/DavidChenLiang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何 Docker 化 Python Django 应用程序
|
Muhammad Arul
|
https://www.howtoforge.com/tutorial/docker-guide-dockerizing-python-django-application/
|
我们将学习如何 docker 化一个 Python Django 应用程序，然后使用一个 docker-compose 脚本将应用程序作为容器部署到 docker 环境。
|
/data/attachment/album/201809/12/224251lbb2vtrfhbq3bb0b.jpg.thumb.jpg
|
/data/attachment/album/201809/12/224251lbb2vtrfhbq3bb0b.jpg
| true | false | true |
MjSeven
|
wxy
| false |
[
"容器",
"Django",
"Docker"
] |
容器与云
|
{
"viewnum": 11296,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们将学习如何 docker 化一个 Python Django 应用程序，然后使用一个 docker-compose 脚本将应用程序作为容器部署到 docker 环境。
| 2018-09-12T22:42:00 | 2018-09-12T22:42:00 | 10,006 |
/article-10006-1.html
|
Docker 是一个开源项目，为开发人员和系统管理员提供了一个开放平台，可以将应用程序构建、打包为一个轻量级容器，并在任何地方运行。Docker 会在软件容器中自动部署应用程序。
Django 是一个用 Python 编写的 Web 应用程序框架，遵循 MVC（模型-视图-控制器）架构。它是免费的，并在开源许可下发布。它速度很快，旨在帮助开发人员尽快将他们的应用程序上线。
在本教程中，我将逐步向你展示在 Ubuntu 16.04 中如何为现有的 Django 应用程序创建 docker 镜像。我们将学习如何 docker 化一个 Python Django 应用程序，然后使用一个 `docker-compose` 脚本将应用程序作为容器部署到 docker 环境。
为了部署我们的 Python Django 应用程序，我们需要其它 docker 镜像：一个用于 Web 服务器的 nginx docker 镜像和用于数据库的 PostgreSQL 镜像。
### 我们要做什么？
1. 安装 Docker-ce
2. 安装 Docker-compose
3. 配置项目环境
4. 构建并运行
5. 测试
### 步骤 1 - 安装 Docker-ce
在本教程中，我们将从 docker 仓库安装 docker-ce 社区版。我们将安装 docker-ce 社区版和 `docker-compose`（其支持 compose 文件版本 3）。
在安装 docker-ce 之前，先使用 `apt` 命令安装所需的 docker 依赖项。
```
sudo apt install -y \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
```
现在通过运行以下命令添加 docker 密钥和仓库。
```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
```
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/1.png)
更新仓库并安装 docker-ce。
```
sudo apt update
sudo apt install -y docker-ce
```
安装完成后，启动 docker 服务并使其能够在每次系统引导时启动。
```
systemctl start docker
systemctl enable docker
```
接着，我们将添加一个名为 `omar` 的新用户并将其添加到 `docker` 组。
```
useradd -m -s /bin/bash omar
usermod -a -G docker omar
```
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/2.png)
以 `omar` 用户身份登录并运行 `docker` 命令，如下所示。
```
su - omar
docker run hello-world
```
确保你能从 Docker 获得 hello-world 消息。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/3.png)
Docker-ce 安装已经完成。
### 步骤 2 - 安装 Docker-compose
在本教程中，我们将使用支持 compose 文件版本 3 的最新 `docker-compose`。我们将手动安装 `docker-compose`。
使用 `curl` 命令将最新版本的 `docker-compose` 下载到 `/usr/local/bin` 目录，并使用 `chmod` 命令使其有执行权限。
运行以下命令：
```
sudo curl -L https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
```
现在检查 `docker-compose` 版本。
```
docker-compose version
```
确保你安装的是最新版本的 docker-compose 1.21。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/4.png)
已安装支持 compose 文件版本 3 的 `docker-compose` 最新版本。
### 步骤 3 - 配置项目环境
在这一步中，我们将配置 Python Django 项目环境。我们将创建新目录 `guide01`，并使其成为我们项目文件的主目录，例如包括 Dockerfile、Django 项目、nginx 配置文件等。
登录到 `omar` 用户。
```
su - omar
```
创建一个新目录 `guide01`，并进入目录。
```
mkdir -p guide01
cd guide01/
```
现在在 `guide01` 目录下，创建两个新目录 `project` 和 `config`。
```
mkdir project/ config/
```
注意：
* `project` 目录：我们所有的 python Django 项目文件都将放在该目录中。
* `config` 目录：项目配置文件的目录，包括 nginx 配置文件、python pip 的`requirements.txt` 文件等。
#### 创建一个新的 requirements.txt 文件
接下来，使用 `vim` 命令在 `config` 目录中创建一个新的 `requirements.txt` 文件。
```
vim config/requirements.txt
```
粘贴下面的配置：
```
Django==2.0.4
gunicorn==19.7.0
psycopg2==2.7.4
```
保存并退出。
#### 创建 Nginx 虚拟主机文件 django.conf
在 `config` 目录下创建 nginx 配置目录并添加虚拟主机配置文件 `django.conf`。
```
mkdir -p config/nginx/
vim config/nginx/django.conf
```
粘贴下面的配置：
```
upstream web {
ip_hash;
server web:8000;
}
# portal
server {
location / {
proxy_pass http://web/;
}
listen 8000;
server_name localhost;
location /static {
autoindex on;
alias /src/static/;
}
}
```
保存并退出。
#### 创建 Dockerfile
在 `guide01` 目录下创建新文件 `Dockerfile`。
运行以下命令：
```
vim Dockerfile
```
现在粘贴下面的 Dockerfile 脚本：
```
FROM python:3.5-alpine
ENV PYTHONUNBUFFERED 1
RUN apk update && \
apk add --virtual build-deps gcc python-dev musl-dev && \
apk add postgresql-dev bash
RUN mkdir /config
ADD /config/requirements.txt /config/
RUN pip install -r /config/requirements.txt
RUN mkdir /src
WORKDIR /src
```
保存并退出。
注意：
我们想要为我们的 Django 项目构建基于 Alpine Linux 的 Docker 镜像，Alpine 是最小的 Linux 版本。我们的 Django 项目将运行在带有 Python 3.5 的 Alpine Linux 上，并添加 postgresql-dev 包以支持 PostgreSQL 数据库。然后，我们将使用 python `pip` 命令安装在 `requirements.txt` 上列出的所有 Python 包，并为我们的项目创建新目录 `/src`。
#### 创建 Docker-compose 脚本
使用 [vim](https://www.howtoforge.com/vim-basics) 命令在 `guide01` 目录下创建 `docker-compose.yml` 文件。
```
vim docker-compose.yml
```
粘贴以下配置内容：
```
version: '3'
services:
db:
image: postgres:10.3-alpine
container_name: postgres01
nginx:
image: nginx:1.13-alpine
container_name: nginx01
ports:
- "8000:8000"
volumes:
- ./project:/src
- ./config/nginx:/etc/nginx/conf.d
depends_on:
- web
web:
build: .
container_name: django01
command: bash -c "python manage.py makemigrations && python manage.py migrate && python manage.py collectstatic --noinput && gunicorn hello_django.wsgi -b 0.0.0.0:8000"
depends_on:
- db
volumes:
- ./project:/src
expose:
- "8000"
restart: always
```
保存并退出。
注意：
使用这个 `docker-compose` 文件脚本，我们将创建三个服务。使用 alpine Linux 版的 PostgreSQL 创建名为 `db` 的数据库服务，再次使用 alpine Linux 版的 Nginx 创建 `nginx` 服务，并使用从 Dockerfile 生成的自定义 docker 镜像创建我们的 python Django 容器。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/5.png)
#### 配置 Django 项目
将 Django 项目文件复制到 `project` 目录。
```
cd ~/django
cp -r * ~/guide01/project/
```
进入 `project` 目录并编辑应用程序设置 `settings.py`。
```
cd ~/guide01/project/
vim hello_django/settings.py
```
注意：
我们将部署名为 “hello\_django” 的简单 Django 应用程序。
在 `ALLOW_HOSTS` 行中，添加服务名称 `web`。
```
ALLOW_HOSTS = ['web']
```
现在更改数据库设置，我们将使用 PostgreSQL 数据库来运行名为 `db` 的服务，使用默认用户和密码。
```
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'postgres',
'USER': 'postgres',
'HOST': 'db',
'PORT': 5432,
}
}
```
至于 `STATIC_ROOT` 配置目录，将此行添加到文件行的末尾。
```
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
```
保存并退出。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/6.png)
现在我们准备在 docker 容器下构建和运行 Django 项目。
### 步骤 4 - 构建并运行 Docker 镜像
在这一步中，我们想要使用 `guide01` 目录中的配置为我们的 Django 项目构建一个 Docker 镜像。
进入 `guide01` 目录。
```
cd ~/guide01/
```
现在使用 `docker-compose` 命令构建 docker 镜像。
```
docker-compose build
```
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/7.png)
启动 `docker-compose` 脚本中的所有服务。
```
docker-compose up -d
```
等待几分钟让 Docker 构建我们的 Python 镜像并下载 nginx 和 postgresql docker 镜像。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/8.png)
完成后，使用以下命令检查运行容器并在系统上列出 docker 镜像。
```
docker-compose ps
docker-compose images
```
现在，你将在系统上运行三个容器，列出 Docker 镜像，如下所示。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/9.png)
我们的 Python Django 应用程序现在在 docker 容器内运行，并且已经创建了为我们服务的 docker 镜像。
### 步骤 5 - 测试
打开 Web 浏览器并使用端口 8000 键入服务器地址，我的是：`http://ovh01:8000/`。
现在你将看到默认的 Django 主页。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/10.png)
接下来，通过在 URL 上添加 `/admin` 路径来测试管理页面。
```
http://ovh01:8000/admin/
```
然后你将会看到 Django 管理登录页面。
[](https://www.howtoforge.com/images/docker_guide_dockerizing_python_django_application/big/11.png)
Docker 化 Python Django 应用程序已成功完成。
### 参考
* <https://docs.docker.com/>
---
via: <https://www.howtoforge.com/tutorial/docker-guide-dockerizing-python-django-application/>
作者：[Muhammad Arul](https://www.howtoforge.com/tutorial/docker-guide-dockerizing-python-django-application/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何在 Ubuntu 或 Linux Mint 启用 Chromium 硬件加速的视频解码
|
Logix
|
https://www.linuxuprising.com/2018/08/how-to-enable-hardware-accelerated.html
|
Chrome/Chromium（Firefox 也是如此，但是 Firefox 的问题没有办法解决）在 Linux 上不支持硬件加速的视频解码。
|
/data/attachment/album/201809/13/002801b8ea5855wfo7v7kw.jpg.thumb.jpg
|
/data/attachment/album/201809/13/002801b8ea5855wfo7v7kw.jpg
| true | false | true |
lujun9972
|
GraveAccent
|
wxy
| false |
[
"Chrome",
"视频",
"硬件加速"
] |
桌面应用
|
{
"viewnum": 8508,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Chrome/Chromium（Firefox 也是如此，但是 Firefox 的问题没有办法解决）在 Linux 上不支持硬件加速的视频解码。
| 2018-09-13T00:28:00 | 2018-09-13T00:28:00 | 10,007 |
/article-10007-1.html
|
你或许已经注意到了，在 Linux 上使用 Google Chrome 或 Chromium 浏览器在 YouTube 或其它类似网站观看高清视频会增加你的 CPU 使用率，如果你用的是笔记本，电脑会发热而且电池会很快用完。这是因为 Chrome/Chromium（Firefox 也是如此，但是 Firefox 的问题没有办法解决）在 Linux 上不支持硬件加速的视频解码。
这篇文章讲述了如何在 Linux 环境安装带有 VA-API 补丁的 Chromium 开发版，它支持 GPU 加速的视频解码，可以显著减少观看在线高清视频时的 CPU 使用率，这篇教程只适用于 Intel 和 Nvidia 的显卡，我没有 ATI/AMD 的显卡可以试验，也没有使用过这几种显卡。
这是 Chromium 浏览器在 Ubuntu18.04 中，在没有 GPU 加速视频解码的情况下播放一个 1080p 的 YouTube 视频：
这是带有 VA-API 补丁的 Chromium 浏览器在 Ubuntu18.04 中，在带有 GPU 加速视频解码的情况下播放同样的 1080p 的 YouTube 视频：
注意截图中的 CPU 使用率。两张截图都是在我老旧而依然强大的桌面计算机上捕捉的。在我的笔记本电脑上，没有硬件加速的 Chromium 带来更高的 CPU 使用率。
“只需 VA-API 即可在 Linux 启用 VAVDA、VAVEA 和 VAJDA” 这个[补丁](https://chromium-review.googlesource.com/c/chromium/src/+/532294)在一年多以前就提交给了 Chromium，但是它还没有合并。
Chrome 有一个选项可以覆盖软件渲染列表（`#ignore-gpu-blacklist`），但是这个选项不能启用硬件加速的视频解码。启用这个选项以后，你或许会在访问 `chrome://gpu` 时发现这些信息：“*Video Decode: Hardware accelerated* “，然而这个并不意味着真的可以工作。在 YouTube 打开一个高清视频并用诸如 `htop` 的工具查看 CPU 使用率（这是我在以上截图中用来查看 CPU 使用率的）。因为 GPU 视频解码没有真的被启用，你应该看到较高的 CPU 使用率。下面有一个部分是关于检查你是否真的在使用硬件加速的视频解码的。
**文中使用的 Chromium 浏览器 Ubuntu 版启用 VA-API 的补丁在[这个地址](https://github.com/saiarcot895/chromium-ubuntu-build/tree/master/debian/patches)可以获得**
### 在 Ubuntu 和 Linux Mint 安装和使用带有 VA-API 支持的 Chromium 浏览器
每个人都该知道 Chromium 开发版本没有理想中那么稳定。所以你可能发现 bug，它可能会发生崩溃等情况。它现在可能正常运行，但是谁知道几次更新以后会发生什么。
还有，如果你想启用 Widevine 支持（这样你才能观看 Netflix 视频和 YouTube 付费视频），Chromium dev 分支 PPA 要求你执行一些额外步骤。 如果你想要一些功能，比如同步，也是如此（需要注册 API 密钥还要在你的系统上设置好）。执行这些任务的说明在 [Chromium 开发版本的 PPA](https://launchpad.net/%7Esaiarcot895/+archive/ubuntu/chromium-dev) 中有详细解释。
对于 Nvidia 显卡，vdpau 视频驱动程序需要更新以便显示 vaQuerySurfaceAttributes。所以 Nvidia 需要使用打过补丁的 vdpau-va-driver。值得庆幸的是，Chromium-dev PPA 提供了这个打过补丁的包。
带有 VA-API 补丁的 Chromium 也可用于其它 Linux 发行版，在第三方仓库，比如说 [Arch Linux](https://aur.archlinux.org/packages/?O=0&SeB=nd&K=chromium+vaapi&outdated=&SB=n&SO=a&PP=50&do_Search=Go)（对于 Nvidia 你需要[这个](https://aur.archlinux.org/packages/libva-vdpau-driver-chromium/)补丁过的 libva-vdpau-driver）。如果你不使用 Ubuntu 或 Linux Mint，你得自己找那些包。
#### 1、安装带有 VA-API 补丁的 Chromium
有一个带 VA-API 补丁的 Chromium Beta PPA，但是它缺少适用于 Ubuntu 18.04 的 vdpau-video。如果你需要，你可以使用这个 [Beta PPA](https://launchpad.net/%7Esaiarcot895/+archive/ubuntu/chromium-beta)，而不是我在下面的步骤中使用 [Dev PPA](https://launchpad.net/%7Esaiarcot895/+archive/ubuntu/chromium-dev/+packages)，不过如果你使用 Nvidia 显卡，你需要从这个 Dev PPA 中下载安装 vdpau-va-driver，并确认 Ubuntu/Linux Mint 不更新这个包（有点复杂，如果你准备根据下面步骤使用 Dev PPA 的话，不需要手动做这些）。
你可以添加 [Chromium 开发分支 PPA](https://launchpad.net/%7Esaiarcot895/+archive/ubuntu/chromium-dev)，并在 Ubuntu 或 Linux Mint（及其它基于 Ubuntu 的发行版，如 elementary，以及 Ubuntu 或 Linux Mint 的风味版，如 Xubuntu、Kubuntu、Ubuntu MATE、Linux Mint MATE 等等）上安装最新的 Chromium 浏览器开发版：
```
sudo add-apt-repository ppa:saiarcot895/chromium-dev
sudo apt-get update
sudo apt install chromium-browser
```
#### 2、安装 VA-API 驱动
对于 Intel 的显卡，你需要安装 `i965-va-driver` 这个包（它可能早就安装好了）
```
sudo apt install i965-va-driver
```
对于 Nvidia 的显卡（在开源的 Nouveau 驱动和闭源的 Nvidia 驱动上，它应该都有效）， 安装 `vdpau-va-driver`：
```
sudo apt install vdpau-va-driver
```
#### 3、在 Chromium 启用硬件加速视频选项
复制这串地址，粘贴进 Chromium 的 URL 栏: `chrome://flags/#enable-accelerated-video` （或者在 `chrome://flags` 搜索 `Hardware-accelerated video` ）并启用它，然后重启 Chromium 浏览器。
在默认的 Google Chrome / Chromium 版本，这个选项不可用，但是你可以在启用了 VP-API 的 Chromium 版本启用它。
#### 4、安装 [h264ify](https://chrome.google.com/webstore/detail/h264ify/aleakchihdccplidncghkekgioiakgal) Chrome 扩展
YouTube（可能还有其它一些网址也是如此）默认使用 VP8 或 VP9 编码解码器，许多 GPU 不支持这种编码解码器的硬件解码。h264ify 会强制 YouTube 使用大多数 GPU 都支持的 H.264 而不是 VP8/VP9。
这个扩展还能阻塞 60fps 的视频，对低性能机器有用。
你可以在视频上右键点击，并且选择 `Stats for nerds` 以查看 Youtube 视频所使用额编码解码器，如果启用了 h264ify 扩展，你可以看到编码解码器是 avc / mp4a。如果没有启用，编码解码器应该是 vp09 / opus。
### 如何检查 Chromium 是否在使用 GPU 视频解码
在 YouTube 打开一个视频，然后，在 Chromium 打开一个新的标签页并将以下地址输入 URL 栏：`chrome://media-internals`。
在 `chrome://media-internals` 标签页中，点击视频的 URL（为了展开它）， 往下滚动查看 `Player Properties` 的下面，你应该可以找到 `video_decoder` 属性。如果`video_decoder` 的值是 `GpuVideoDecoder` ，这说明当前在另一个标签页播放的 YouTube 视频正在使用硬件加速的的视频解码。
如果它显示的是 `FFmpegVideoDecoder` 或 `VpxVideoDecoder` ，说明加速视频解码无效或者你忘记安装或禁用了 h264ify 这个 Chrome 扩展。
如果无效，你可以通过在命令行运行 `chromium-browser` ，通过查看是否有 VA-API 相关的错误显示出来以调试。你也可以运行 `vainfo`（在 Ubuntu 或 Linux Mint 上安装：`sudo apt install vainfo`）和 `vdpauinfo` （对于 Nvidia，在 Ubuntu 或 Linux Mint 上安装：`sudo apt install vdpauinfo`）并且查看是否有显示任何错误。
---
via: <https://www.linuxuprising.com/2018/08/how-to-enable-hardware-accelerated.html>
作者：[Logix](https://plus.google.com/118280394805678839070) 选题：[lujun9972](https://github.com/lujun9972) 译者：[GraveAccent](https://github.com/GraveAccent) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
8 个用于业余项目的优秀 Python 库
|
Jeff Triplett
|
https://opensource.com/article/18/9/python-libraries-side-projects
|
这些库可以使你更容易构架个人项目。
|
/data/attachment/album/201809/13/083258l7vk8lqln1f0q2lz.png.thumb.jpg
|
/data/attachment/album/201809/13/083258l7vk8lqln1f0q2lz.png
| true | false | true |
lujun9972
|
ucasFL
|
wxy
| false |
[
"Python"
] |
软件开发
|
{
"viewnum": 6182,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这些库可以使你更容易构架个人项目。
| 2018-09-13T08:32:54 | 2018-09-13T08:32:54 | 10,008 |
/article-10008-1.html
|
>
> 这些库可以使你更容易构架个人项目。
>
>
>
在 Python/Django 的世界里有这样一个谚语：为语言而来，为社区而留。对绝大多数人来说的确是这样的，但是，还有一件事情使得我们一直停留在 Python 的世界里，不愿离开，那就是我们可以很容易地利用一顿午餐或晚上几个小时的时间，把一个想法快速地实现出来。
这个月，我们来探讨一些我们喜欢用来快速完成<ruby> 业余项目 <rt> side projects </rt></ruby>或打发午餐时间的 Python 库。
### 在数据库中即时保存数据：Dataset
当我们想要在不知道最终数据库表长什么样的情况下，快速收集数据并保存到数据库中的时候，[Dataset](https://dataset.readthedocs.io/en/latest/) 库将是我们的最佳选择。Dataset 库有一个简单但功能强大的 API，因此我们可以很容易的把数据保存下来，之后再进行整理。
Dataset 建立在 SQLAlchemy 之上，所以如果需要对它进行扩展，你会感到非常熟悉。使用 Django 内建的 [inspectdb](https://docs.djangoproject.com/en/2.1/ref/django-admin/#django-admin-inspectdb) 管理命令可以很容易地把底层数据库模型导入 Django 中，这使得和现有数据库一同工作不会出现任何障碍。
### 从网页抓取数据：Beautiful Soup
[Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/)（一般写作 BS4）库使得从 HTML 网页中提取信息变得非常简单。当我们需要把非结构化或弱结构化的 HTML 转换为结构化数据的时候，就需要使用 Beautiful Soup 。用它来处理 XML 数据也是一个很好的选择，否则 XML 的可读性或许会很差。
### 和 HTTP 内容打交道：Requests
当需要和 HTTP 内容打交道的时候，[Requests](http://docs.python-requests.org/) 毫无疑问是最好的标准库。当我们想要抓取 HTML 网页或连接 API 的时候，都离不开 Requests 库。同时，它也有很好的文档。
### 编写命令行工具：Click
当需要写一个简单的 Python 脚本作为命令行工具的时候，[Click](http://click.pocoo.org/5/) 是我最喜欢用的库。它的 API 非常直观，并且在实现时经过了深思熟虑，我们只需要记住很少的几个模式。它的文档也很优秀，这使得学习其高级特性更加容易。
### 对事物命名：Python Slugify
众所周知，命名是一件困难的事情。[Python Slugify](https://github.com/un33k/python-slugify) 是一个非常有用的库，它可以把一个标题或描述转成一个带有特性的唯一标识符。如果你正在做一个 Web 项目，并且你想要使用对<ruby> 搜索引擎优化友好 <rt> SEO-friendly </rt></ruby>的链接，那么，使用 Python Slugify 可以让这件事变得很容易。
### 和插件打交道：Pluggy
[Pluggy](https://pluggy.readthedocs.io/en/latest/) 库相对较新，但是如果你想添加一个插件系统到现有应用中，那么使用 Pluggy 是最好也是最简单的方式。如果你使用过 pytest，那么实际上相当于已经使用过 Pluggy 了，虽然你还不知道它。
### 把 CSV 文件转换到 API 中：DataSette
[DataSette](https://github.com/simonw/datasette) 是一个神奇的工具，它可以很容易地把 CSV 文件转换为全特性的只读 REST JSON API，同时，不要把它和 Dataset 库混淆。Datasette 有许多特性，包括创建图表和 geo（用于创建交互式地图），并且很容易通过容器或第三方网络主机进行部署。
### 处理环境变量等：Envparse
如果你不想在源代码中保存 API 密钥、数据库凭证或其他敏感信息，那么你便需要解析环境变量，这时候 [envparse](https://github.com/rconradharris/envparse) 是最好的选择。Envparse 能够处理环境变量、ENV 文件、变量类型，甚至还可以进行预处理和后处理（例如，你想要确保变量名总是大写或小写的）。
有什么你最喜欢的用于业余项目的 Python 库不在这个列表中吗？请在评论中和我们分享。
---
via: <https://opensource.com/article/18/9/python-libraries-side-projects>
作者：[Jeff Triplett](https://opensource.com/users/laceynwilliams) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 中压缩和解压缩文件
|
Sk
|
https://www.ostechnix.com/how-to-compress-and-decompress-files-in-linux/
|
当在备份重要文件和通过网络发送大文件的时候，对文件进行压缩非常有用。
|
/data/attachment/album/201809/13/220019yu6qw083583xp8lz.jpg.thumb.jpg
|
/data/attachment/album/201809/13/220019yu6qw083583xp8lz.jpg
| true | false | true |
lujun9972
|
ucasFL
|
wxy
| false |
[
"gzip",
"bzip2",
"压缩"
] |
技术
|
{
"viewnum": 6082,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当在备份重要文件和通过网络发送大文件的时候，对文件进行压缩非常有用。
| 2018-09-13T22:00:17 | 2018-09-13T22:00:17 | 10,009 |
/article-10009-1.html
|
当在备份重要文件和通过网络发送大文件的时候，对文件进行压缩非常有用。请注意，压缩一个已经压缩过的文件会增加额外开销，因此你将会得到一个更大一些的文件。所以，请不要压缩已经压缩过的文件。在 GNU/Linux 中，有许多程序可以用来压缩和解压缩文件。在这篇教程中，我们仅学习其中两个应用程序。
在类 Unix 系统中，最常见的用来压缩文件的程序是：
1. gzip
2. bzip2
### 1. 使用 gzip 程序来压缩和解压缩文件
`gzip` 是一个使用 Lempel-Ziv 编码（LZ77）算法来压缩和解压缩文件的实用工具。
#### 1.1 压缩文件
如果要压缩一个名为 `ostechnix.txt` 的文件，使之成为 gzip 格式的压缩文件，那么只需运行如下命令：
```
$ gzip ostechnix.txt
```
上面的命令运行结束之后，将会出现一个名为 `ostechnix.txt.gz` 的 gzip 格式压缩文件，代替了原始的 `ostechnix.txt` 文件。
`gzip` 命令还可以有其他用法。一个有趣的例子是，我们可以将一个特定命令的输出通过管道传递，然后作为 `gzip` 程序的输入来创建一个压缩文件。看下面的命令：
```
$ ls -l Downloads/ | gzip > ostechnix.txt.gz
```
上面的命令将会创建一个 gzip 格式的压缩文件，文件的内容为 `Downloads` 目录的目录项。
#### 1.2 压缩文件并将输出写到新文件中（不覆盖原始文件）
默认情况下，`gzip` 程序会压缩给定文件，并以压缩文件替代原始文件。但是，你也可以保留原始文件，并将输出写到标准输出。比如，下面这个命令将会压缩 `ostechnix.txt` 文件，并将输出写入文件 `output.txt.gz`。
```
$ gzip -c ostechnix.txt > output.txt.gz
```
类似地，要解压缩一个 `gzip` 格式的压缩文件并指定输出文件的文件名，只需运行：
```
$ gzip -c -d output.txt.gz > ostechnix1.txt
```
上面的命令将会解压缩 `output.txt.gz` 文件，并将输出写入到文件 `ostechnix1.txt` 中。在上面两个例子中，原始文件均不会被删除。
#### 1.3 解压缩文件
如果要解压缩 `ostechnix.txt.gz` 文件，并以原始未压缩版本的文件来代替它，那么只需运行：
```
$ gzip -d ostechnix.txt.gz
```
我们也可以使用 `gunzip` 程序来解压缩文件：
```
$ gunzip ostechnix.txt.gz
```
#### 1.4 在不解压缩的情况下查看压缩文件的内容
如果你想在不解压缩的情况下，使用 `gzip` 程序查看压缩文件的内容，那么可以像下面这样使用 `-c` 选项：
```
$ gunzip -c ostechnix1.txt.gz
```
或者，你也可以像下面这样使用 `zcat` 程序：
```
$ zcat ostechnix.txt.gz
```
你也可以通过管道将输出传递给 `less` 命令，从而一页一页的来查看输出，就像下面这样：
```
$ gunzip -c ostechnix1.txt.gz | less
$ zcat ostechnix.txt.gz | less
```
另外，`zless` 程序也能够实现和上面的管道同样的功能。
```
$ zless ostechnix1.txt.gz
```
#### 1.5 使用 gzip 压缩文件并指定压缩级别
`gzip` 的另外一个显著优点是支持压缩级别。它支持下面给出的 3 个压缩级别：
* **1** – 最快 (最差)
* **9** – 最慢 (最好)
* **6** – 默认级别
要压缩名为 `ostechnix.txt` 的文件，使之成为“最好”压缩级别的 gzip 压缩文件，可以运行：
```
$ gzip -9 ostechnix.txt
```
#### 1.6 连接多个压缩文件
我们也可以把多个需要压缩的文件压缩到同一个文件中。如何实现呢？看下面这个例子。
```
$ gzip -c ostechnix1.txt > output.txt.gz
$ gzip -c ostechnix2.txt >> output.txt.gz
```
上面的两个命令将会压缩文件 `ostechnix1.txt` 和 `ostechnix2.txt`，并将输出保存到一个文件 `output.txt.gz` 中。
你可以通过下面其中任何一个命令，在不解压缩的情况下，查看两个文件 `ostechnix1.txt` 和 `ostechnix2.txt` 的内容：
```
$ gunzip -c output.txt.gz
$ gunzip -c output.txt
$ zcat output.txt.gz
$ zcat output.txt
```
如果你想了解关于 `gzip` 的更多细节，请参阅它的 man 手册。
```
$ man gzip
```
### 2. 使用 bzip2 程序来压缩和解压缩文件
`bzip2` 和 `gzip` 非常类似，但是 `bzip2` 使用的是 Burrows-Wheeler 块排序压缩算法，并使用<ruby> 哈夫曼 <rt> Huffman </rt></ruby>编码。使用 `bzip2` 压缩的文件以 “.bz2” 扩展结尾。
正如我上面所说的， `bzip2` 的用法和 `gzip` 几乎完全相同。只需在上面的例子中将 `gzip` 换成 `bzip2`，将 `gunzip` 换成 `bunzip2`，将 `zcat` 换成 `bzcat` 即可。
要使用 `bzip2` 压缩一个文件，并以压缩后的文件取而代之，只需运行：
```
$ bzip2 ostechnix.txt
```
如果你不想替换原始文件，那么可以使用 `-c` 选项，并把输出写入到新文件中。
```
$ bzip2 -c ostechnix.txt > output.txt.bz2
```
如果要解压缩文件，则运行：
```
$ bzip2 -d ostechnix.txt.bz2
```
或者，
```
$ bunzip2 ostechnix.txt.bz2
```
如果要在不解压缩的情况下查看一个压缩文件的内容，则运行：
```
$ bunzip2 -c ostechnix.txt.bz2
```
或者，
```
$ bzcat ostechnix.txt.bz2
```
如果你想了解关于 `bzip2` 的更多细节，请参阅它的 man 手册。
```
$ man bzip2
```
### 总结
在这篇教程中，我们学习了 `gzip` 和 `bzip2` 程序是什么，并通过 GNU/Linux 下的一些例子学习了如何使用它们来压缩和解压缩文件。接下来，我们将要学习如何在 Linux 中将文件和目录归档。
干杯！
---
via: <https://www.ostechnix.com/how-to-compress-and-decompress-files-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
理解监测指标，并使用 Python 去监测它们
|
Amit Saha
|
https://opensource.com/article/18/4/metrics-monitoring-and-python
|
通过学习这些关键的术语和概念来理解 Python 应用监测。
|
/data/attachment/album/201809/14/095110zhc8emsexexmuon8.png.thumb.jpg
|
/data/attachment/album/201809/14/095110zhc8emsexexmuon8.png
| true | false | true |
lujun9972
|
qhwdw
|
wxy
| false |
[
"监测",
"Python",
"指标"
] |
软件开发
|
{
"viewnum": 6383,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过学习这些关键的术语和概念来理解 Python 应用监测。
| 2018-09-14T09:51:06 | 2018-09-14T09:51:06 | 10,011 |
/article-10011-1.html
|
>
> 通过学习这些关键的术语和概念来理解 Python 应用监测。
>
>
>
当我第一次看到术语“<ruby> 计数器 <rt> counter </rt></ruby>”和“<ruby> 计量器 <rt> gauge </rt></ruby>”和使用颜色及标记着“平均数”和“大于 90%”的数字图表时，我的反应之一是逃避。就像我看到它们一样，我并不感兴趣，因为我不理解它们是干什么的或如何去使用。因为我的工作不需要我去注意它们，它们被我完全无视。
这都是在两年以前的事了。随着我的职业发展，我希望去了解更多关于我们的网络应用程序的知识，而那个时候就是我开始去学习<ruby> 监测指标 <rt> metrics </rt></ruby>的时候。
我的理解监测的学习之旅共有三个阶段（到目前为止），它们是：
* 阶段 1：什么？（王顾左右）
* 阶段 2：没有指标，我们真的是瞎撞。
* 阶段 3：出现不合理的指标我们该如何做？
我现在处于阶段 2，我将分享到目前为止我学到了些什么。我正在向阶段 3 进发，在本文结束的位置我提供了一些我正在使用的学习资源。
我们开始吧！
### 需要的软件
在文章中讨论时用到的 demo 都可以在 [我的 GitHub 仓库](https://github.com/amitsaha/python-monitoring-talk) 中找到。你需要安装 docker 和 docker-compose 才能使用它们。
### 为什么要监测？
关于监测的主要原因是：
* 理解 正常的 和 不正常的 系统和服务的特征
* 做容量规划、弹性伸缩
* 有助于排错
* 了解软件/硬件改变的效果
* 测量响应中的系统行为变化
* 当系统出现意外行为时发出警报
### 指标和指标类型
从我们的用途来看，一个**指标**就是在一个给定*时间*点上的某些数量的 测量 值。博客文章的总点击次数、参与讨论的总人数、在缓存系统中数据没有被找到的次数、你的网站上的已登录用户数 —— 这些都是指标的例子。
它们总体上可以分为三类：
#### 计数器
以你的个人博客为例。你发布一篇文章后，过一段时间后，你希望去了解有多少点击量，这是一个只会增加的数字。这就是一个<ruby> 计数器 <rt> counter </rt></ruby>指标。在你的博客文章的生命周期中，它的值从 0 开始增加。用图表来表示，一个计数器看起来应该像下面的这样：
*一个计数器指标总是在增加的。*
#### 计量器
如果你想去跟踪你的博客每天或每周的点击量，而不是基于时间的总点击量。这种指标被称为一个<ruby> 计量器 <rt> gauge </rt></ruby>，它的值可上可下。用图表来表示，一个计量器看起来应该像下面的样子：
*一个计量器指标可以增加或减少。*
一个计量器的值在某些时间窗口内通常有一个<ruby> 最大值 <rt> ceiling </rt></ruby>和<ruby最小值floor。
#### 柱状图和计时器
<ruby> 柱状图 <rt> histogram </rt></ruby>（在 Prometheus 中这么叫它）或<ruby> 计时器 <rt> timer </rt></ruby>（在 StatsD 中这么叫它）是一个跟踪 已采样的观测结果 的指标。不像一个计数器类或计量器类指标，柱状图指标的值并不是显示为上或下的样式。我知道这可能并没有太多的意义，并且可能和一个计量器图看上去没有什么不同。它们的不同之处在于，你期望使用柱状图数据来做什么，而不是与一个计量器图做比较。因此，监测系统需要知道那个指标是一个柱状图类型，它允许你去做哪些事情。
*一个柱状图指标可以增加或减少。*
### Demo 1：计算和报告指标
[Demo 1](https://github.com/amitsaha/python-monitoring-talk/tree/master/demo1) 是使用 [Flask](http://flask.pocoo.org/) 框架写的一个基本的 web 应用程序。它演示了我们如何去 计算 和 报告 指标。
在 `src` 目录中有 `app.py` 和 `src/helpers/middleware.py` 应用程序，包含以下内容：
```
from flask import request
import csv
import time
def start_timer():
request.start_time = time.time()
def stop_timer(response):
# convert this into milliseconds for statsd
resp_time = (time.time() - request.start_time)*1000
with open('metrics.csv', 'a', newline='') as f:
csvwriter = csv.writer(f)
csvwriter.writerow([str(int(time.time())), str(resp_time)])
return response
def setup_metrics(app):
app.before_request(start_timer)
app.after_request(stop_timer)
```
当在应用程序中调用 `setup_metrics()` 时，它配置在一个请求被处理之前调用 `start_timer()` 函数，然后在该请求处理之后、响应发送之前调用 `stop_timer()` 函数。在上面的函数中，我们写了时间戳并用它来计算处理请求所花费的时间。
当我们在 `demo1` 目录中运行 `docker-compose up`，它会启动这个 web 应用程序，然后在一个客户端容器中可以生成一些对 web 应用程序的请求。你将会看到创建了一个 `src/metrics.csv` 文件，它有两个字段：`timestamp` 和 `request_latency`。
通过查看这个文件，我们可以推断出两件事情：
* 生成了很多数据
* 没有观测到任何与指标相关的特征
没有观测到与指标相关的特征，我们就不能说这个指标与哪个 HTTP 端点有关联，或这个指标是由哪个应用程序的节点所生成的。因此，我们需要使用合适的元数据去限定每个观测指标。
### 《Statistics 101》
（LCTT 译注：这是一本统计学入门教材的名字）
假如我们回到高中数学，我们应该回忆起一些统计术语，虽然不太确定，但应该包括平均数、中位数、百分位和柱状图。我们来简要地回顾一下它们，不用去管它们的用法，就像是在上高中一样。
#### 平均数
<ruby> 平均数 <rt> mean </rt></ruby>，即一系列数字的平均值，是将数字汇总然后除以列表的个数。3、2 和 10 的平均数是 (3+2+10)/3 = 5。
#### 中位数
<ruby> 中位数 <rt> median </rt></ruby>是另一种类型的平均，但它的计算方式不同；它是列表从小到大排序（反之亦然）后取列表的中间数字。以我们上面的列表中（2、3、10），中位数是 3。计算并不是非常直观，它取决于列表中数字的个数。
#### 百分位
<ruby> 百分位 <rt> percentile </rt></ruby>是指那个百（千）分比数字低于我们给定的百分数的程度。在一些场景中，它是指这个测量值低于我们数据的百（千）分比数字的程度。比如，上面列表中 95% 是 9.29999。百分位的测量范围是 0 到 100（不包括）。0% 是一组数字的最小分数。你可能会想到它的中位数是 50%，它的结果是 3。
一些监测系统将百分位称为 `upper_X`，其中 X 就是百分位；`upper 90` 指的是在 90% 的位置的值。
#### 分位数
“q-分位数”是将有 N 个数的集合等分为 `qN` 级。`q` 的取值范围为 0 到 1（全部都包括）。当 `q` 取值为 0.5 时，值就是中位数。（<ruby> 分位数 <rt> quantile </rt></ruby>）和百分位数的关系是，分位数值 `q` 等于 `100` 百分位值。
#### 柱状图
<ruby柱状图histogram这个指标，我们前面学习过，它是监测系统中一个实现细节。在统计学中，一个柱状图是一个将数据分组为 桶 的图表。我们来考虑一个人为的不同示例：阅读你的博客的人的年龄。如果你有一些这样的数据，并想将它进行大致的分组，绘制成的柱状图将看起来像下面的这样：
#### 累积柱状图
一个<ruby> 累积柱状图 <rt> cumulative histogram </rt></ruby>也是一个柱状图，它的每个桶的数包含前一个桶的数，因此命名为累积。将上面的数据集做成累积柱状图后，看起来应该是这样的：
#### 我们为什么需要做统计？
在上面的 Demo 1 中，我们注意到在我们报告指标时，这里生成了许多数据。当我们将它们用于指标时我们需要做统计，因为它们实在是太多了。我们需要的是整体行为，我们没法去处理单个值。我们预期展现出来的值的行为应该是代表我们观察的系统的行为。
### Demo 2：在指标上增加特征
在我们上面的的 Demo 1 应用程序中，当我们计算和报告一个请求的延迟时，它指向了一个由一些特征 唯一标识的特定请求。下面是其中一些：
* HTTP 端点
* HTTP 方法
* 运行它的主机/节点的标识符
如果我们将这些特征附加到要观察的指标上，每个指标将有更多的内容。我们来解释一下 [Demo 2](https://github.com/amitsaha/python-monitoring-talk/tree/master/demo2) 中添加到我们的指标上的特征。
在写入指标时，`src/helpers/middleware.py` 文件将在 CSV 文件中写入多个列：
```
node_ids = ['10.0.1.1', '10.1.3.4']
def start_timer():
request.start_time = time.time()
def stop_timer(response):
# convert this into milliseconds for statsd
resp_time = (time.time() - request.start_time)*1000
node_id = node_ids[random.choice(range(len(node_ids)))]
with open('metrics.csv', 'a', newline='') as f:
csvwriter = csv.writer(f)
csvwriter.writerow([
str(int(time.time())), 'webapp1', node_id,
request.endpoint, request.method, str(response.status_code),
str(resp_time)
])
return response
```
因为这只是一个演示，在报告指标时，我们将随意的报告一些随机 IP 作为节点的 ID。当我们在 `demo2` 目录下运行 `docker-compose up` 时，我们的结果将是一个有多个列的 CSV 文件。
#### 用 pandas 分析指标
我们将使用 [pandas](https://pandas.pydata.org/) 去分析这个 CSV 文件。运行 `docker-compose up` 将打印出一个 URL，我们将使用它来打开一个 [Jupyter](http://jupyter.org/) 会话。一旦我们上传 `Analysis.ipynb notebook` 到会话中，我们就可以将 CSV 文件读入到一个 pandas <ruby> 数据帧 <rt> DataFrame </rt></ruby>中：
```
import pandas as pd
metrics = pd.read_csv('/data/metrics.csv', index_col=0)
```
`index_col` 表明我们要指定时间戳作为索引。
因为每个特征我们都要在数据帧中添加一个列，因此我们可以基于这些列进行分组和聚合：
```
import numpy as np
metrics.groupby(['node_id', 'http_status']).latency.aggregate(np.percentile, 99.999)
```
更多内容请参考 Jupyter notebook 在数据上的分析示例。
### 我应该监测什么？
一个软件系统有许多的变量，这些变量的值在它的生命周期中不停地发生变化。软件是运行在某种操作系统上的，而操作系统同时也在不停地变化。在我看来，当某些东西出错时，你所拥有的数据越多越好。
我建议去监测的关键操作系统指标有：
* CPU 使用
* 系统内存使用
* 文件描述符使用
* 磁盘使用
还需要监测的其它关键指标根据你的软件应用程序不同而不同。
#### 网络应用程序
如果你的软件是一个监听客户端请求和为它提供服务的网络应用程序，需要测量的关键指标还有：
* 入站请求数（计数器）
* 未处理的错误（计数器）
* 请求延迟（柱状图/计时器）
* 排队时间，如果在你的应用程序中有队列（柱状图/计时器）
* 队列大小，如果在你的应用程序中有队列（计量器）
* 工作进程/线程用量（计量器）
如果你的网络应用程序在一个客户端请求的环境中向其它服务发送请求，那么它应该有一个指标去记录它与那个服务之间的通讯行为。需要监测的关键指标包括请求数、请求延迟、和响应状态。
#### HTTP web 应用程序后端
HTTP 应用程序应该监测上面所列出的全部指标。除此之外，还应该按 HTTP 状态代码分组监测所有非 200 的 HTTP 状态代码的大致数据。如果你的 web 应用程序有用户注册和登录功能，同时也应该为这个功能设置指标。
#### 长时间运行的进程
长时间运行的进程如 Rabbit MQ 消费者或任务队列的工作进程，虽然它们不是网络服务，它们以选取一个任务并处理它的工作模型来运行。因此，我们应该监测请求的进程数和这些进程的请求延迟。
不管是什么类型的应用程序，都有指标与合适的**元数据**相关联。
### 将监测集成到一个 Python 应用程序中
将监测集成到 Python 应用程序中需要涉及到两个组件：
* 更新你的应用程序去计算和报告指标
* 配置一个监测基础设施来容纳应用程序的指标，并允许去查询它们
下面是记录和报告指标的基本思路：
```
def work():
requests += 1
# report counter
start_time = time.time()
# < do the work >
# calculate and report latency
work_latency = time.time() - start_time
...
```
考虑到上面的模式，我们经常使用修饰符、内容管理器、中间件（对于网络应用程序）所带来的好处去计算和报告指标。在 Demo 1 和 Demo 2 中，我们在一个 Flask 应用程序中使用修饰符。
#### 指标报告时的拉取和推送模型
大体来说，在一个 Python 应用程序中报告指标有两种模式。在 拉取 模型中，监测系统在一个预定义的 HTTP 端点上“刮取”应用程序。在推送 模型中，应用程序发送数据到监测系统。
工作在 拉取 模型中的监测系统的一个例子是 [Prometheus](https://prometheus.io/)。而 [StatsD](https://github.com/etsy/statsd) 是 推送 模型的一个例子。
#### 集成 StatsD
将 StatsD 集成到一个 Python 应用程序中，我们将使用 [StatsD Python 客户端](https://pypi.python.org/pypi/statsd)，然后更新我们的指标报告部分的代码，调用合适的库去推送数据到 StatsD 中。
首先，我们需要去创建一个客户端实例：
```
statsd = statsd.StatsClient(host='statsd', port=8125, prefix='webapp1')
```
`prefix` 关键字参数将为通过这个客户端报告的所有指标添加一个指定的前缀。
一旦我们有了客户端，我们可以使用如下的代码为一个计时器报告值：
```
statsd.timing(key, resp_time)
```
增加计数器：
```
statsd.incr(key)
```
将指标关联到元数据上，一个键的定义为：`metadata1.metadata2.metric`，其中每个 metadataX 是一个可以进行聚合和分组的字段。
这个演示应用程序 [StatsD](https://github.com/amitsaha/python-monitoring-talk/tree/master/statsd) 是将 statsd 与 Python Flask 应用程序集成的一个完整示例。
#### 集成 Prometheus
要使用 Prometheus 监测系统，我们使用 [Promethius Python 客户端](https://pypi.python.org/pypi/prometheus_client)。我们将首先去创建有关的指标类对象：
```
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency',
['app_name', 'endpoint']
)
```
在上面的语句中的第三个参数是与这个指标相关的标识符。这些标识符是由与单个指标值相关联的元数据定义的。
去记录一个特定的观测指标：
```
REQUEST_LATENCY.labels('webapp', request.path).observe(resp_time)
```
下一步是在我们的应用程序中定义一个 Prometheus 能够刮取的 HTTP 端点。这通常是一个被称为 `/metrics` 的端点：
```
@app.route('/metrics')
def metrics():
return Response(prometheus_client.generate_latest(), mimetype=CONTENT_TYPE_LATEST)
```
这个演示应用程序 [Prometheus](https://github.com/amitsaha/python-monitoring-talk/tree/master/prometheus) 是将 prometheus 与 Python Flask 应用程序集成的一个完整示例。
#### 哪个更好：StatsD 还是 Prometheus？
本能地想到的下一个问题便是：我应该使用 StatsD 还是 Prometheus？关于这个主题我写了几篇文章，你可能发现它们对你很有帮助：
* [使用 Prometheus 监测多进程 Python 应用的方式](http://echorand.me/your-options-for-monitoring-multi-process-python-applications-with-prometheus.html)
* [使用 Prometheus 监测你的同步 Python 应用](https://blog.codeship.com/monitoring-your-synchronous-python-web-applications-using-prometheus/)
* [使用 Prometheus 监测你的异步 Python 应用](https://blog.codeship.com/monitoring-your-asynchronous-python-web-applications-using-prometheus/)
### 指标的使用方式
我们已经学习了一些关于为什么要在我们的应用程序上配置监测的原因，而现在我们来更深入地研究其中的两个用法：报警和自动扩展。
#### 使用指标进行报警
指标的一个关键用途是创建警报。例如，假如过去的五分钟，你的 HTTP 500 的数量持续增加，你可能希望给相关的人发送一封电子邮件或页面提示。对于配置警报做什么取决于我们的监测设置。对于 Prometheus 我们可以使用 [Alertmanager](https://github.com/prometheus/alertmanager)，而对于 StatsD，我们使用 [Nagios](https://www.nagios.org/about/overview/)。
#### 使用指标进行自动扩展
在一个云基础设施中，如果我们当前的基础设施供应过量或供应不足，通过指标不仅可以让我们知道，还可以帮我们实现一个自动伸缩的策略。例如，如果在过去的五分钟里，在我们服务器上的工作进程使用率达到 90%，我们可以水平扩展。我们如何去扩展取决于云基础设施。AWS 的自动扩展，缺省情况下，扩展策略是基于系统的 CPU 使用率、网络流量、以及其它因素。然而，让基础设施伸缩的应用程序指标，我们必须发布 [自定义的 CloudWatch 指标](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/publishingMetrics.html)。
### 在多服务架构中的应用程序监测
当我们超越一个单应用程序架构时，比如当客户端的请求在响应被发回之前，能够触发调用多个服务，就需要从我们的指标中获取更多的信息。我们需要一个统一的延迟视图指标，这样我们就能够知道响应这个请求时每个服务花费了多少时间。这可以用 [分布式跟踪](http://opentracing.io/documentation/) 来实现。
你可以在我的博客文章 《[在你的 Python 应用程序中通过 Zipkin 引入分布式跟踪](http://echorand.me/introducing-distributed-tracing-in-your-python-application-via-zipkin.html)》 中看到在 Python 中进行分布式跟踪的示例。
### 划重点
总之，你需要记住以下几点：
* 理解你的监测系统中指标类型的含义
* 知道监测系统需要的你的数据的测量单位
* 监测你的应用程序中的大多数关键组件
* 监测你的应用程序在它的大多数关键阶段的行为
以上要点是假设你不去管理你的监测系统。如果管理你的监测系统是你的工作的一部分，那么你还要考虑更多的问题！
### 其它资源
以下是我在我的监测学习过程中找到的一些非常有用的资源：
#### 综合的
* [监测分布式系统](https://landing.google.com/sre/book/chapters/monitoring-distributed-systems.html)
* [观测和监测最佳实践](http://www.integralist.co.uk/posts/monitoring-best-practices/?imm_mid=0fbebf&cmp=em-webops-na-na-newsltr_20180309)
* [谁想使用秒？](https://www.robustperception.io/who-wants-seconds/)
#### StatsD/Graphite
* [StatsD 指标类型](https://github.com/etsy/statsd/blob/master/docs/metric_types.md)
#### Prometheus
* [Prometheus 指标类型](https://prometheus.io/docs/concepts/metric_types/)
* [Prometheus 计量器如何工作？](https://www.robustperception.io/how-does-a-prometheus-gauge-work/)
* [为什么用 Prometheus 累积柱形图？](https://www.robustperception.io/why-are-prometheus-histograms-cumulative/)
* [在 Python 中监测批量作业](https://www.robustperception.io/monitoring-batch-jobs-in-python/)
* [Prometheus：监测 SoundCloud](https://developers.soundcloud.com/blog/prometheus-monitoring-at-soundcloud)
### 避免犯错（即第 3 阶段的学习）
在我们学习监测的基本知识时，时刻注意不要犯错误是很重要的。以下是我偶然发现的一些很有见解的资源：
* [如何不测量延迟](https://www.youtube.com/watch?v=lJ8ydIuPFeU&feature=youtu.be)
* [Prometheus 柱形图：悲伤的故事](http://linuxczar.net/blog/2017/06/15/prometheus-histogram-2/)
* [为什么平均值很讨厌，而百分位很棒](https://www.dynatrace.com/news/blog/why-averages-suck-and-percentiles-are-great/)
* [对延迟的认知错误](https://bravenewgeek.com/everything-you-know-about-latency-is-wrong/)
* [谁动了我的 99% 延迟？](https://engineering.linkedin.com/performance/who-moved-my-99th-percentile-latency)
* [日志、指标和图形](https://grafana.com/blog/2016/01/05/logs-and-metrics-and-graphs-oh-my/)
* [HdrHistogram：一个更好的延迟捕获方式](http://psy-lob-saw.blogspot.com.au/2015/02/hdrhistogram-better-latency-capture.html)
---
想学习更多内容，参与到 [PyCon Cleveland 2018](https://us.pycon.org/2018/) 上的 Amit Saha 的讨论，[Counter, gauge, upper 90—Oh my!](https://us.pycon.org/2018/schedule/presentation/133/)
### 关于作者
Amit Saha — 我是一名对基础设施、监测、和工具感兴趣的软件工程师。我是“用 Python 做数学”的作者和创始人，以及 Fedora Scientific Spin 维护者。
[关于我的更多信息](https://opensource.com/users/amitsaha)
---
via: <https://opensource.com/article/18/4/metrics-monitoring-and-python>
作者: [Amit Saha](https://opensource.com/users/amitsaha) 选题者: [lujun9972](https://github.com/lujun9972) 译者: [qhwdw](https://github.com/qhwdw) 校对: [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
面向敏捷开发团队的 7 个开源项目管理工具
|
Opensource.com
|
https://opensource.com/article/18/2/agile-project-management-tools
|
在这篇开源项目管理工具的综述中，让我们来了解一下支持 Scrum、看板等敏捷开发模式的软件。
|
/data/attachment/album/201809/14/123409ffp336i76r63gtly.png.thumb.jpg
|
/data/attachment/album/201809/14/123409ffp336i76r63gtly.png
| true | false | true |
heguangzhi
|
wxy
| false |
[
"项目管理",
"敏捷"
] |
分享
|
{
"viewnum": 19997,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇开源项目管理工具的综述中，让我们来了解一下支持 Scrum、看板等敏捷开发模式的软件。
| 2018-09-14T12:34:06 | 2018-09-14T12:34:06 | 10,012 |
/article-10012-1.html
|
>
> 在这篇开源项目管理工具的综述中，让我们来了解一下支持 Scrum、<ruby> 看板 <rt> Kanban </rt></ruby> 等敏捷开发模式的软件。
>
>
>
Opensource.com 以前对流行的开源项目管理工具做过相应的调研。但是今年我们增加了一个特点。本次，我们特别关注支持[敏捷](http://agilemanifesto.org/principles.html)方法的工具，包括相关的实践，如 [Scrum](https://opensource.com/resources/scrum)、Lean 和 <ruby> 看板 <rt> Kanban </rt></ruby>。
对敏捷开发的兴趣和使用的增长是我们今年决定专注于这些工具的原因。大多数组织（71%）的人说他们至少[使用了敏捷方式](https://www.pmi.org/-/media/pmi/documents/public/pdf/learning/thought-leadership/pulse/pulse-of-the-profession-2017.pdf)。此外，敏捷项目比传统方法管理的项目 [要高出 28% 的成功率](https://www.pwc.com/gx/en/actuarial-insurance-services/assets/agile-project-delivery-confidence.pdf) 。
我们查看了 [2014](https://opensource.com/business/14/1/top-project-management-tools-2014)、[2015](https://opensource.com/business/15/1/top-project-management-tools-2015) 和 [2016](https://opensource.com/business/16/3/top-project-management-tools-2016) 中涉及的项目管理工具，并挑选了支持敏捷的工具，然后对没有涉及的或变化了的进行了研究。不管您的组织是否已经在使用敏捷开发，或者在 2018 年的众多计划之一是采用敏捷方法，这七个开源项目管理工具之一可能正是您所要找寻的。
### MyCollab
[MyCollab](https://community.mycollab.com/) 是一套针对中小型企业的三个协作模块套件：项目管理、客户关系管理（CRM）和文档创建和编辑软件。有两个许可证选项：一个商业的“终极”版本，它更快，可以在内部或云中运行；另一个开源的“社区版本”，这个正是我们感兴趣的版本。
由于没有使用查询缓存，社区版本没有云方式，并且速度较慢，但是提供了基本的项目管理特性，包括任务、问题管理、活动流、路线图视图和敏捷团队看板。虽然它没有单独的移动应用程序，但它也适用于移动设备，包括 Windows、Mac OS、Linux 和 UNIX 计算机。
MyCollab 的最新版本是 5.4.10，源代码可在 [GitHub](https://github.com/MyCollab/mycollab) 上下载。它是在 AGPLv3 下进行授权的，需要 Java 运行时环境和 MySQL 支持。它可运行于 Windows、Linux、UNIX 和 MacOS。[下载地址](https://www.mycollab.com/ce-registration/)。
### Odoo
[Odoo](https://www.odoo.com/) 不仅仅是项目管理软件；它是一个完整的集成商业应用套件，包括会计、人力资源、网站和电子商务、库存、制造、销售管理（CRM）和其它工具。
与付费企业套件相比，免费的开源社区版具有有限的 [特性](https://www.odoo.com/page/editions) 。它的项目管理应用程序包括敏捷团队的看板式任务跟踪视图，在最新版本 Odoo 11.0 中更新了该视图，以包括用于跟踪项目状态的进度条和动画。项目管理工具还包括甘特图、任务、问题、图表等等。Odoo 有一个繁荣的[社区](https://www.odoo.com/page/community)，并提供 [用户指南](https://www.odoo.com/documentation/user/11.0/) 及其他培训资源。
它是在 GPLv3 下授权的，需要 Python 和 PostgreSQL 支持。作为[Docker](https://hub.docker.com/_/odoo/) 镜像 可以运行在 Windows、Linux 和 Red Hat 包管理器中，下载地址[download](https://www.odoo.com/page/download)，源代码[GitHub](https://github.com/odoo/odoo)。
### OpenProject
[OpenProject](https://www.openproject.org/) 是一个强大的开源项目管理工具，以其易用性和丰富的项目管理和团队协作特性而著称。
它的模块支持项目计划、调度、路线图和发布计划、时间跟踪、成本报告、预算、bug 跟踪以及敏捷和 Scrum。它的敏捷特性，包括创建 Story、确定 sprint 的优先级以及跟踪任务，都与 OpenProject 的其他模块集成在一起。
OpenProject 在 GPLv3 下获得许可，其源代码可在[GitHub](https://github.com/opf/openproject)上。最新版本 7.3.2 的 Linux 版本 [在此下载](https://www.openproject.org/download-and-installation/)；您可以在 Birthe Lindenthal 的文章 “[OpenProject 入门](https://opensource.com/article/17/11/how-install-and-use-openproject)”中了解更多关于安装和配置它的信息。
### OrangeScrum
正如从其名称中猜到的，[OrangeScrum](https://www.orangescrum.org/) 支持敏捷方法，特别是使用 Scrum 任务板和看板式工作流视图。它面向较小的组织自由职业者、中介机构和中小型企业。
开源版本提供了 OrangeScrum 付费版本中的许多 [特性](https://www.orangescrum.org/compare-orangescrum)，包括移动应用程序、资源利用率和进度跟踪。其他特性，包括甘特图、时间日志、发票和客户端管理，可以作为付费附加组件提供，付费版本包括云选项，而社区版本不提供。
OrangeScrum 是基于 GPLv3 授权的，是基于 CakePHP 框架开发。它需要 Apache、PHP 5.3 或更高版本和 MySQL 4.1 或更高版本支持，并可以在 Windows、Linux 和 Mac OS 上运行。其最新版本 1.1.1 [在此下载](http://www.orangescrum.org/free-download)，其源码在 [GitHub](https://github.com/Orangescrum/orangescrum/)。
### ]project-open[
[]project-open[](http://www.project-open.com/en/list-installers) 是一个双许可证的企业项目管理工具，这意味着其核心是开源的，并且在商业许可的模块中可以使用一些附加特性。根据该项目的社区和企业版本的 [比较](http://www.project-open.com/en/products/editions.html)，开源核心为中小型组织提供了许多特性。
]project-open[ 支持带有 Scrum 和看板功能的 [敏捷](http://www.project-open.com/en/project-type-agile) 项目，以及经典的甘特/瀑布项目和混合或混合项目。
该应用程序是在 GPL 下授权的，并且 [源代码](http://www.project-open.com/en/developers-cvs-checkout)是通过 CVS 访问的。 ]project-open[ 在 Linux 和 Windows 的安装有 [安装程序](http://www.project-open.com/en/list-installers)，但也可以在云镜像和虚拟设备中使用。
### Taiga
[Taiga](https://taiga.io/) 是一个开源项目管理平台，它专注于 Scrum 和敏捷开发，其特征包括看板、任务、sprints、问题、backlog 和 epics。其他功能包括凭证管理、多项目支持、Wiki 页面和第三方集成。
它还为 iOS、Android 和 Windows 设备提供免费的移动应用程序，并提供导入工具，使从其他流行的项目管理应用程序迁移变得容易。
Taiga 对于公共项目是免费的，对项目数量或用户数量没有限制。对于私有项目，在“免费增值”模式下，有很多 [付费计划](https://tree.taiga.io/support/subscription-and-plans/payment-process-faqs/#q.-what-s-about-custom-plans-private-projects-with-more-than-25-members-?) 可用，但是值得注意的是，无论您属于哪种类型，软件的功能特性都是一样的。
Taiga 是在 GNU Affero GPLv3 下授权的，并且软件需要 Nginx、Python 和 PostgreSQL 支持。最新版本[3.1.0 Perovskia atriplicifolia](https://blog.taiga.io/taiga-perovskia-atriplicifolia-release-310.html)，可在 [GitHub](https://github.com/taigaio) 上下载。
### Tuleap
[Tuleap](https://www.tuleap.org/) 是一个应用程序生命周期管理（ALM）平台，旨在为每种类型的团队管理项目——小型、中型、大型、瀑布、敏捷或混合型——但是它对敏捷团队的支持是显著的。值得注意的是，它为 Scrum、看板、sprints、任务、报告、持续集成、backlogs 等提供支持.
其他的 [特性](https://www.tuleap.org/features/project-management) 包括问题跟踪、文档跟踪、协作工具，以及与 Git、SVN 和 Jenkins 的集成，所有这些都使它成为开放源码软件开发项目的吸引人的选择。
Tuleap 是在 GPLv2 下授权的。更多信息，包括 Docker 和 CentOS 下载，可以在他们的 [入门](https://www.tuleap.org/get-started) 页面上找到。您还可以在 Tuleap 的 [Git](https://tuleap.net/plugins/git/tuleap/tuleap/stable) 上获取其最新版本 9.14 的源代码。
---
这种类型的文章的麻烦在于它一发布就过时了。您正在使用哪些开源项目管理工具，而被我们遗漏了？或者您对我们提到的有反馈意见吗？请在下面留下留言。
---
via: <https://opensource.com/article/18/2/agile-project-management-tools>
作者：[Opensource.com](https://opensource.com) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Filelight：可视化查看 Linux 系统上的磁盘使用情况
|
Sk
|
https://www.ostechnix.com/filelight-visualize-disk-usage-on-your-linux-system/
|
这是一个图形化实用程序，用于可视化显示 Linux 系统上的磁盘使用情况，并以彩色径向图显示结果。
|
/data/attachment/album/201809/14/162326kkzjez5xj3plel0z.png.thumb.jpg
|
/data/attachment/album/201809/14/162326kkzjez5xj3plel0z.png
| true | false | true |
lujun9972
|
XiatianSummer
|
wxy
| false |
[
"磁盘",
"du"
] |
分享
|
{
"viewnum": 10852,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这是一个图形化实用程序，用于可视化显示 Linux 系统上的磁盘使用情况，并以彩色径向图显示结果。
| 2018-09-14T16:23:24 | 2018-09-14T16:23:24 | 10,013 |
/article-10013-1.html
|
查看硬盘使用情况对于类 Unix 操作系统来说不是什么大问题。我们有一个名为 [du](https://www.ostechnix.com/find-size-directory-linux/) 的内置命令，可以在几分钟之内计算和汇总磁盘空间的使用情况。此外，我们还有一些第三方工具，比如 [Ncdu](https://www.ostechnix.com/check-disk-space-usage-linux-using-ncdu/) 和 [Agedu](https://www.ostechnix.com/agedu-find-out-wasted-disk-space-in-linux/)，它们也可以用来追踪磁盘使用情况。如您所见，这些都是命令行中的实用程序，磁盘使用情况将以纯文本的形式显示。但是，有些人希望以可视化、图表的形式查看结果。别担心！我知道一个 GUI 工具可以显示磁盘使用细节。它就是 “**Filelight**”，这是一个图形化实用程序，用于可视化显示 Linux 系统上的磁盘使用情况，并以彩色径向图显示结果。Filelight 是历史最悠久的项目之一，它已经存在了很长时间，它完全免费使用并开源。
### 安装 Filelight
Filelight 是 KDE 应用程序的一部分，并预装在基于 KDE 的 Linux 发行版上。
如果您使用的是非 KDE 发行版，官方存储库中包含了 Filelight，因此您可以使用默认的包管理器进行安装。
在 Arch Linux 及其衍生版，如 Antergos、Manjaro Linux 中，Filelight 可以按照如下方法安装。
```
$ sudo pacman -S filelight
```
在 Debian、Ubuntu、Linux Mint 中，
```
$ sudo apt install filelight
```
在 Fedora 中，
```
$ sudo dnf install filelight
```
在 openSUSE 中，
```
$ sudo zypper install filelight
```
### 可视化查看 Linux 系统上的磁盘使用情况
安装后，从菜单或应用程序启动器启动 Filelight。
Filelight 以图形方式将您的文件系统表示为一组同心圆环段。
如您所见，Filelight 默认显示磁盘中 `/` 和 `/boot` 文件系统的使用情况。
您还可以选择扫描的各个文件夹，以查看该特定文件夹的磁盘使用情况。为此，请到 “Filelight -> Scan -> Scan Folder” 并选择要扫描的文件夹。
Filelight 在扫描时排除以下目录：
* `/dev`
* `/proc`
* `/sys`
* `/root`
此选项有助于跳过您可能没有权限读取的目录，或者属于虚拟文件系统的文件夹，例如 `/proc`。
如果您想要在此列表中增加文件夹，请到 “Filelight -> Settings -> Scanning” 并点击 “Add” 按钮然后选择您想要增加的文件夹。
类似的，要想从此列表中移除某个文件夹，选择文件夹并点击 “Remove”。
如果您想要改变 Filelight 的外观，请到 “Settings - > Appearance” 栏，按照您的喜好改变配色方案。
径向图中的每个段用不同的颜色表示。下图显示了 `/` 文件系统的整个径向布局。要查看文件和文件夹的完整信息，只需将鼠标指针悬停在它们上边。
只需点击相应的段即可浏览文件系统。要查看某个文件或文件夹的磁盘使用情况，只需单击它们即可获得该特定文件夹、文件的完整磁盘使用情况。
不仅仅是本地文件系统，Filelight 还能够扫描远程磁盘和可移动磁盘。 如果您使用任何基于 KDE 的 Linux 发行版，它可以集成到 Konqueror、Dolphin 和 Krusader 等文件管理器中。
与 CLI 实用程序不同，您不必使用任何额外的参数或选项来以易读的（而非乱码的）格式查看结果。 默认情况下，Filelight 将自动以易读的格式显示磁盘使用情况。
### 总结
使用 Filelight，您可以快速找到文件系统中占用磁盘空间的位置，并通过删除不需要的文件或文件夹释放空间。 如果您正在寻找一些简单且易上手的图形界面磁盘使用情况查看器，那么 Filelight 值得一试。
就是这样。希望这篇文章对您有用。更多的好文章，敬请关注！
干杯！
---
via: <https://www.ostechnix.com/filelight-visualize-disk-usage-on-your-linux-system/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[XiatianSummer](https://github.com/XiatianSummer) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我为什么喜欢 Xonsh
|
Moshe Zadka
|
https://opensource.com/article/18/9/xonsh-bash-alternative
|
有没有想过用 Python 做你的 shell？
|
/data/attachment/album/201809/14/165925olhlknllrofn23th.png.thumb.jpg
|
/data/attachment/album/201809/14/165925olhlknllrofn23th.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[] |
技术
|
{
"viewnum": 6959,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有没有想过用 Python 做你的 shell？
| 2018-09-14T16:59:22 | 2018-09-14T16:59:22 | 10,014 |
/article-10014-1.html
|
>
> 有没有想过用 Python 做你的 shell？
>
>
>
Shell 语言对交互式使用很有用。但是在使用它们作为编程语言时这种优化就需要权衡，有时在编写 shell 脚本时会感觉到这点。
如果你的 shell 也能理解一种更可伸缩的语言会怎样？比如说，Python？
进入 [Xonsh](https://xon.sh/)。
安装 Xonsh 就像创建虚拟环境一样简单，运行 `pip install xonsh [ptk，linux]`，然后运行 `xonsh`。
首先，你可能奇怪为什么你的 Python shell 有一个奇怪的提示：
```
$ 1+1
2
```
好的，计算器！
```
$ print("hello world")
hello world
```
我们还可以调用其他函数：
```
$ from antigravity import geohash
$ geohash(37.421542, -122.085589, b'2005-05-26-10458.68')
37.857713 -122.544543
```
然而，我们仍然可以像常规 shell 一样使用它：
```
$ echo "hello world"
hello world
```
我们甚至可以混搭！
```
$ for i in range(3):
. echo "hello world"
.
hello world
hello world
hello world
```
Xonsh 支持使用 [Prompt Toolkit](https://python-prompt-toolkit.readthedocs.io/en/master/) 补全 shell 命令和 Python 表达式。补全有可视化提示，会显示可能的补全并有下拉列表。
它还支持访问环境变量。它使用简单但强大的启发式方法将 Python 类型应用于环境变量。默认值为 “string”，但是，例如，路径变量是自动列表。
```
$ '/usr/bin' in $PATH
True
```
Xonsh 接受 shell 形式或 Python 形式的布尔快捷运算符：
```
$ cat things
foo
$ grep -q foo things and echo "found"
found
$ grep -q bar things && echo "found"
$ grep -q foo things or echo "found"
$ grep -q bar things || echo "found"
found
```
这意味着 Python 关键字是被解释了。如果我们想要打印著名的《苏斯博士》书的标题，我们需要引用关键词。
```
$ echo green eggs "and" ham
green eggs and ham
```
如果我们不这样做，我们会感到惊讶：
```
$ echo green eggs and ham
green eggs
xonsh: For full traceback set: $XONSH_SHOW_TRACEBACK = True
xonsh: subprocess mode: command not found: ham
Did you mean one of the following?
as: Command (/usr/bin/as)
ht: Command (/usr/bin/ht)
mag: Command (/usr/bin/mag)
ar: Command (/usr/bin/ar)
nm: Command (/usr/bin/nm)
```
虚拟环境可能会有点棘手。一般的虚拟环境（取决于它们类似 Bash 的语法）无法工作。但是，Xonsh 自带了一个名为 `vox` 的虚拟环境管理系统。
`vox` 可以创建、激活和停用 `~/.virtualenvs` 中的环境。如果你用过 `virtualenvwrapper`，这就是环境变量所在的地方。
请注意，当前激活的环境不会影响 `xonsh`。它无法从激活的环境中导入任何内容。
```
$ xontrib load vox
$ vox create my-environment
...
$ vox activate my-environment
Activated "my-environment".
$ pip install money
...
$ python
...
>>> import money
>>> money.Money('3.14')
$ import money
xonsh: For full traceback set: $XONSH_SHOW_TRACEBACK = True
ModuleNotFoundError: No module named 'money'
```
第一行启用 `vox`：它是一个 `xontrib`，是 Xonsh 的一个第三方扩展。`xontrib` 管理器可以列出所有可能的 `xontribs` 及其当前状态（已安装、已加载或未加载）。
可以编写一个 `xontrib` 并上传到 `PyPi` 以使其可用。但是，最好将它添加到 `xontrib` 索引中，以便 Xonsh 提前知道它。比如，这能让配置向导建议它。
如果你曾经想过，“Python 可以成为我的 shell 吗？”，然后你只要 `pip install xonsh` 一下就能知道。
---
via: <https://opensource.com/article/18/9/xonsh-bash-alternative>
作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Distrochooser 帮助 Linux 初学者选择合适的 Linux 发行版
|
Sk
|
https://www.ostechnix.com/distrochooser-helps-linux-beginners-to-choose-a-suitable-linux-distribution/
|
令我惊讶的是，它确实做得很好。结果对我来说几乎是准确的。
|
/data/attachment/album/201809/15/083642qag0ch50t5hzqvqp.png.thumb.jpg
|
/data/attachment/album/201809/15/083642qag0ch50t5hzqvqp.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"发行版"
] |
分享
|
{
"viewnum": 5380,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "112.17.109.207",
"message": "站点无法访问呀",
"username": "独立奔走的靴子 [Firefox 52.0|GNU/Linux]",
"date": "2018-09-19T18:34:31"
}
] |
[] |
令我惊讶的是，它确实做得很好。结果对我来说几乎是准确的。
| 2018-09-15T08:36:00 | 2018-09-15T08:36:00 | 10,015 |
/article-10015-1.html
|
你好 Linux 新手！今天，我为你们带来了一个好消息！你也许想知道如何选择合适的 Linux 发行版。当然，你可能已经咨询过一些 Linux 专家来帮助你的需要选择 Linux 发行版。你们中的一些人可能已经用 Google 搜索并浏览了各种资源、Linux 论坛、网站和博客来寻找完美的发行版。好了，你不必再那样做了。有了 **Distrochooser**，一个帮助你轻松找到 Linux 发行版的网站。
### Distrochooser 如何帮助 Linux 初学者选择合适的 Linux 发行版？
Distrochooser 会根据你的答案向你询问一系列问题并建议你尝试不同的 Linux 发行版。激动吗？太好了！让我们继续看看如何找到合适的 Linux 发行版。单击以下链接开始。
你将被重定向到 Distrochooser 主页，其中有一个小测试在等待你注册。
你需要回答一系列问题（准确地说是 16 个问题）。问题同时有单选和多选。以下是完整的问题列表。
1. 软件：使用情况
2. 计算机知识
3. Linux 知识
4. 安装：预设
5. 安装：需要 Live 测试么？
6. 安装：硬件支持
7. 配置：帮助源
8. 发行版：用户体验概念
9. 发行版：价格
10. 发行版：范围
11. 发行版：意识形态
12. 发行版：隐私
13. 发行版：预设主题，图标和壁纸
14. 发行版：特色
15. 软件：管理
16. 软件：更新
仔细阅读问题并在相应问题下面选择合适的答案。Distrochooser 提供了更多选择来选择接近完美的发行版。
* 你总是可以跳过问题，
* 你可以随时点击“获取结果”，
* 你可以任意顺序回答，
* 你可以随时删除答案，
* 你可以在测试结束时对属性进行加权，以强调对你来说重要的内容。
选择问题的答案后，单击“Proceed”以转到下一个问题。完成后，单击“Get Result”按钮。你也可以通过单击答案下面的“Clear”按钮随时清除选择。
### 结果？
我以前不相信 Distrochooser 会找到我想要的东西。哦，我错了！令我惊讶的是，它确实做得很好。结果对我来说几乎是准确的。我期待 Arch Linux 在结果中，结果确实是在推荐第一位，接下来是其他 11 个建议，如 NixOS、Void Linux、Qubes OS、Scientific Linux、Devuan、Gentoo Linux、Bedrock Linux、Slackware、CentOS、Linux from scratch、Redhat Enterprise Linux。总共有 12 个推荐，每个结果都非常详细，带有发行版的描述和主页。
我在 Reddit 上发布了 Distrochooser 链接，80％ 的用户可以找到合适的 Linux 发行版。但是，我不会声称 Distrochooser 足以为每个人找到好结果。一些用户对调查结果感到失望，甚至结果与他们使用中或者想要使用的一点不接近。因此，我强烈建议你在尝试任何 Linux 之前咨询其他 Linux 专家、网站和论坛。你可以在[**这里**](https://www.reddit.com/r/linux/comments/93p6az/distrochooser_helps_linux_beginners_to_choose_a/)阅读完整的 Reddit 讨论。
你在等什么？进入 Distrochooser 网站并为你选择合适的 Linux 发行版吧。
就是这些了。还有更多好东西。敬请期待！
干杯!
---
via: <https://www.ostechnix.com/distrochooser-helps-linux-beginners-to-choose-a-suitable-linux-distribution/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 FreeBSD 上设置 PF 防火墙来保护 Web 服务器
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-set-up-a-firewall-with-pf-on-freebsd-to-protect-a-web-server/
|
在 FreeBSD 上，我该如何设置 PF 防火墙，来保护只有一个公共 IP 地址和端口的 web 服务器呢？
|
/data/attachment/album/201809/15/223918yw8s808787d6707q.jpg.thumb.jpg
|
/data/attachment/album/201809/15/223918yw8s808787d6707q.jpg
| true | false | true |
ucasFL
|
wxy
| false |
[
"防火墙",
"BSD"
] |
系统运维
|
{
"viewnum": 8015,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 FreeBSD 上，我该如何设置 PF 防火墙，来保护只有一个公共 IP 地址和端口的 web 服务器呢？
| 2018-09-15T22:39:00 | 2018-09-15T22:39:00 | 10,016 |
/article-10016-1.html
|
我是从 Linux 迁移过来的 FreeBSD 新用户，Linux 中使用的是 netfilter 防火墙框架（LCTT 译注：netfilter 是由 Rusty Russell 提出的 Linux 2.4 内核防火墙框架）。那么在 FreeBSD 上，我该如何设置 PF 防火墙，来保护只有一个公共 IP 地址和端口的 web 服务器呢？
PF 是<ruby> 包过滤器 <rt> packet filter </rt></ruby>的简称。它是为 OpenBSD 开发的，但是已经被移植到了 FreeBSD 以及其它操作系统上。PF 是一个包状态过滤引擎。在这篇教程中，我将向你展示如何在 FreeBSD 10.x 以及 11.x 中设置 PF 防火墙，从而来保护 web 服务器。
### 第一步：开启 PF 防火墙
你需要把下面这几行内容添加到文件 `/etc/rc.conf` 文件中：
```
# echo 'pf_enable="YES"' >> /etc/rc.conf
# echo 'pf_rules="/usr/local/etc/pf.conf"' >> /etc/rc.conf
# echo 'pflog_enable="YES"' >> /etc/rc.conf
# echo 'pflog_logfile="/var/log/pflog"' >> /etc/rc.conf
```
在这里：
1. `pf_enable="YES"` - 开启 PF 服务
2. `pf_rules="/usr/local/etc/pf.conf"` - 从文件 `/usr/local/etc/pf.conf` 中读取 PF 规则
3. `pflog_enable="YES"` - 为 PF 服务打开日志支持
4. `pflog_logfile="/var/log/pflog"` - 存储日志的文件，即日志存于文件 `/var/log/pflog` 中
### 第二步：在 `/usr/local/etc/pf.conf` 文件中创建防火墙规则
输入下面这个命令打开文件（超级用户模式下）：
```
# vi /usr/local/etc/pf.conf
```
在文件中添加下面这些 PF 规则集：
```
# vim: set ft=pf
# /usr/local/etc/pf.conf
## 设置公共端口 ##
ext_if="vtnet0"
## 设置服务器公共 IP 地址 ##
ext_if_ip="172.xxx.yyy.zzz"
## 设置并删除下面这些公共端口上的 IP 范围 ##
martians = "{ 127.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12, \
10.0.0.0/8, 169.254.0.0/16, 192.0.2.0/24, \
0.0.0.0/8, 240.0.0.0/4 }"
## 设置 http(80)/https (443) 端口 ##
webports = "{http, https}"
## 启用下面这些服务 ##
int_tcp_services = "{domain, ntp, smtp, www, https, ftp, ssh}"
int_udp_services = "{domain, ntp}"
## 跳过回环端口 - 跳过端口上的所有 PF 处理 ##
set skip on lo
## 设置 PF 应该统计的端口信息，如发送/接收字节数，通过/禁止的包的数目 ##
set loginterface $ext_if
## 设置默认策略 ##
block return in log all
block out all
# 基于 IP 分片的错误处理来防御攻击
scrub in all
# 删除所有不可达路由地址
block drop in quick on $ext_if from $martians to any
block drop out quick on $ext_if from any to $martians
## 禁止欺骗包
antispoof quick for $ext_if
# 打开 SSH 端口，SSH 服务仅从 VPN IP 139.xx.yy.zz 监听 22 号端口
# 出于安全原因，我不允许/接收 SSH 流量
pass in quick on $ext_if inet proto tcp from 139.xxx.yyy.zzz to $ext_if_ip port = ssh flags S/SA keep state label "USER_RULE: Allow SSH from 139.xxx.yyy.zzz"
## 使用下面这些规则来为所有来自任何 IP 地址的用户开启 SSH 服务 #
## pass in inet proto tcp to $ext_if port ssh
### [ OR ] ###
## pass in inet proto tcp to $ext_if port 22
# Allow Ping-Pong stuff. Be a good sysadmin
pass inet proto icmp icmp-type echoreq
# All access to our Nginx/Apache/Lighttpd Webserver ports
pass proto tcp from any to $ext_if port $webports
# 允许重要的发送流量
pass out quick on $ext_if proto tcp to any port $int_tcp_services
pass out quick on $ext_if proto udp to any port $int_udp_services
# 在下面添加自定义规则
```
保存并关闭文件。欢迎来参考我的[规则集](https://github.com/nixcraft/pf.conf/blob/master/pf.conf)。如果要检查语法错误，可以运行：
```
# service pf check
```
或
```
/etc/rc.d/pf check
```
或
```
# pfctl -n -f /usr/local/etc/pf.conf
```
### 第三步：开始运行 PF 防火墙
命令如下。请小心，如果是基于 SSH 的会话，你可能会和服务器断开连接。
#### 开启 PF 防火墙：
```
# service pf start
```
#### 停用 PF 防火墙：
```
# service pf stop
```
#### 检查语法错误：
```
# service pf check
```
#### 重启服务：
```
# service pf restart
```
#### 查看 PF 状态：
```
# service pf status
```
示例输出：
```
Status: Enabled for 0 days 00:02:18 Debug: Urgent
Interface Stats for vtnet0 IPv4 IPv6
Bytes In 19463 0
Bytes Out 18541 0
Packets In
Passed 244 0
Blocked 3 0
Packets Out
Passed 136 0
Blocked 12 0
State Table Total Rate
current entries 1
searches 395 2.9/s
inserts 4 0.0/s
removals 3 0.0/s
Counters
match 19 0.1/s
bad-offset 0 0.0/s
fragment 0 0.0/s
short 0 0.0/s
normalize 0 0.0/s
memory 0 0.0/s
bad-timestamp 0 0.0/s
congestion 0 0.0/s
ip-option 0 0.0/s
proto-cksum 0 0.0/s
state-mismatch 0 0.0/s
state-insert 0 0.0/s
state-limit 0 0.0/s
src-limit 0 0.0/s
synproxy 0 0.0/s
map-failed 0 0.0/s
```
#### 开启/关闭/重启 pflog 服务的命令
输入下面这些命令：
```
# service pflog start
# service pflog stop
# service pflog restart
```
### 第四步：`pfctl` 命令的简单介绍
你需要使用 `pfctl` 命令来查看 PF 规则集和参数配置，包括来自<ruby> 包过滤器 <rt> packet filter </rt></ruby>的状态信息。让我们来看一下所有常见命令：
#### 显示 PF 规则信息
```
# pfctl -s rules
```
示例输出：
```
block return in log all
block drop out all
block drop in quick on ! vtnet0 inet from 172.xxx.yyy.zzz/24 to any
block drop in quick inet from 172.xxx.yyy.zzz/24 to any
pass in quick on vtnet0 inet proto tcp from 139.aaa.ccc.ddd to 172.xxx.yyy.zzz/24 port = ssh flags S/SA keep state label "USER_RULE: Allow SSH from 139.aaa.ccc.ddd"
pass inet proto icmp all icmp-type echoreq keep state
pass out quick on vtnet0 proto tcp from any to any port = domain flags S/SA keep state
pass out quick on vtnet0 proto tcp from any to any port = ntp flags S/SA keep state
pass out quick on vtnet0 proto tcp from any to any port = smtp flags S/SA keep state
pass out quick on vtnet0 proto tcp from any to any port = http flags S/SA keep state
pass out quick on vtnet0 proto tcp from any to any port = https flags S/SA keep state
pass out quick on vtnet0 proto tcp from any to any port = ftp flags S/SA keep state
pass out quick on vtnet0 proto tcp from any to any port = ssh flags S/SA keep state
pass out quick on vtnet0 proto udp from any to any port = domain keep state
pass out quick on vtnet0 proto udp from any to any port = ntp keep state
```
#### 显示每条规则的详细内容
```
# pfctl -v -s rules
```
在每条规则的详细输出中添加规则编号：
```
# pfctl -vvsr show
```
#### 显示状态信息
```
# pfctl -s state
# pfctl -s state | more
# pfctl -s state | grep 'something'
```
#### 如何在命令行中禁止 PF 服务
```
# pfctl -d
```
#### 如何在命令行中启用 PF 服务
```
# pfctl -e
```
#### 如何在命令行中刷新 PF 规则/NAT/路由表
```
# pfctl -F all
```
示例输出：
```
rules cleared
nat cleared
0 tables deleted.
2 states cleared
source tracking entries cleared
pf: statistics cleared
pf: interface flags reset
```
#### 如何在命令行中仅刷新 PF 规则
```
# pfctl -F rules
```
#### 如何在命令行中仅刷新队列
```
# pfctl -F queue
```
#### 如何在命令行中刷新统计信息（它不是任何规则的一部分）
```
# pfctl -F info
```
#### 如何在命令行中清除所有计数器
```
# pfctl -z clear
```
### 第五步：查看 PF 日志
PF 日志是二进制格式的。使用下面这一命令来查看：
```
# tcpdump -n -e -ttt -r /var/log/pflog
```
示例输出：
```
Aug 29 15:41:11.757829 rule 0/(match) block in on vio0: 86.47.225.151.55806 > 45.FOO.BAR.IP.23: S 757158343:757158343(0) win 52206 [tos 0x28]
Aug 29 15:41:44.193309 rule 0/(match) block in on vio0: 5.196.83.88.25461 > 45.FOO.BAR.IP.26941: S 2224505792:2224505792(0) ack 4252565505 win 17520 (DF) [tos 0x24]
Aug 29 15:41:54.628027 rule 0/(match) block in on vio0: 45.55.13.94.50217 > 45.FOO.BAR.IP.465: S 3941123632:3941123632(0) win 65535
Aug 29 15:42:11.126427 rule 0/(match) block in on vio0: 87.250.224.127.59862 > 45.FOO.BAR.IP.80: S 248176545:248176545(0) win 28200 <mss 1410,sackOK,timestamp 1044055305 0,nop,wscale 8> (DF)
Aug 29 15:43:04.953537 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.7475: S 1164335542:1164335542(0) win 1024
Aug 29 15:43:05.122156 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.7475: R 1164335543:1164335543(0) win 1200
Aug 29 15:43:37.302410 rule 0/(match) block in on vio0: 94.130.12.27.18080 > 45.FOO.BAR.IP.64857: S 683904905:683904905(0) ack 4000841729 win 16384 <mss 1460>
Aug 29 15:44:46.574863 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.7677: S 3451987887:3451987887(0) win 1024
Aug 29 15:44:46.819754 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.7677: R 3451987888:3451987888(0) win 1200
Aug 29 15:45:21.194752 rule 0/(match) block in on vio0: 185.40.4.130.55910 > 45.FOO.BAR.IP.80: S 3106068642:3106068642(0) win 1024
Aug 29 15:45:32.999219 rule 0/(match) block in on vio0: 185.40.4.130.55910 > 45.FOO.BAR.IP.808: S 322591763:322591763(0) win 1024
Aug 29 15:46:30.157884 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.6511: S 2412580953:2412580953(0) win 1024 [tos 0x28]
Aug 29 15:46:30.252023 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.6511: R 2412580954:2412580954(0) win 1200 [tos 0x28]
Aug 29 15:49:44.337015 rule 0/(match) block in on vio0: 189.219.226.213.22640 > 45.FOO.BAR.IP.23: S 14807:14807(0) win 14600 [tos 0x28]
Aug 29 15:49:55.161572 rule 0/(match) block in on vio0: 5.196.83.88.25461 > 45.FOO.BAR.IP.40321: S 1297217585:1297217585(0) ack 1051525121 win 17520 (DF) [tos 0x24]
Aug 29 15:49:59.735391 rule 0/(match) block in on vio0: 36.7.147.209.2545 > 45.FOO.BAR.IP.3389: SWE 3577047469:3577047469(0) win 8192 <mss 1460,nop,wscale 8,nop,nop,sackOK> (DF) [tos 0x2 (E)]
Aug 29 15:50:00.703229 rule 0/(match) block in on vio0: 36.7.147.209.2546 > 45.FOO.BAR.IP.3389: SWE 1539382950:1539382950(0) win 8192 <mss 1460,nop,wscale 8,nop,nop,sackOK> (DF) [tos 0x2 (E)]
Aug 29 15:51:33.880334 rule 0/(match) block in on vio0: 45.55.22.21.53510 > 45.FOO.BAR.IP.2362: udp 14
Aug 29 15:51:34.006656 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.6491: S 151489102:151489102(0) win 1024 [tos 0x28]
Aug 29 15:51:34.274654 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.6491: R 151489103:151489103(0) win 1200 [tos 0x28]
Aug 29 15:51:36.393019 rule 0/(match) block in on vio0: 60.191.38.78.4249 > 45.FOO.BAR.IP.8000: S 3746478095:3746478095(0) win 29200 (DF)
Aug 29 15:51:57.213051 rule 0/(match) block in on vio0: 24.137.245.138.7343 > 45.FOO.BAR.IP.5358: S 14134:14134(0) win 14600
Aug 29 15:52:37.852219 rule 0/(match) block in on vio0: 122.226.185.125.51128 > 45.FOO.BAR.IP.23: S 1715745381:1715745381(0) win 5840 <mss 1420,sackOK,timestamp 13511417 0,nop,wscale 2> (DF)
Aug 29 15:53:31.309325 rule 0/(match) block in on vio0: 189.218.148.69.377 > 45.FOO.BAR.IP5358: S 65340:65340(0) win 14600 [tos 0x28]
Aug 29 15:53:31.809570 rule 0/(match) block in on vio0: 13.93.104.140.53184 > 45.FOO.BAR.IP.1433: S 39854048:39854048(0) win 1024
Aug 29 15:53:32.138231 rule 0/(match) block in on vio0: 13.93.104.140.53184 > 45.FOO.BAR.IP.1433: R 39854049:39854049(0) win 1200
Aug 29 15:53:41.459088 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.6028: S 168338703:168338703(0) win 1024
Aug 29 15:53:41.789732 rule 0/(match) block in on vio0: 77.72.82.22.47218 > 45.FOO.BAR.IP.6028: R 168338704:168338704(0) win 1200
Aug 29 15:54:34.993594 rule 0/(match) block in on vio0: 212.47.234.50.5102 > 45.FOO.BAR.IP.5060: udp 408 (DF) [tos 0x28]
Aug 29 15:54:57.987449 rule 0/(match) block in on vio0: 51.15.69.145.5100 > 45.FOO.BAR.IP.5060: udp 406 (DF) [tos 0x28]
Aug 29 15:55:07.001743 rule 0/(match) block in on vio0: 190.83.174.214.58863 > 45.FOO.BAR.IP.23: S 757158343:757158343(0) win 27420
Aug 29 15:55:51.269549 rule 0/(match) block in on vio0: 142.217.201.69.26112 > 45.FOO.BAR.IP.22: S 757158343:757158343(0) win 22840 <mss 1460>
Aug 29 15:58:41.346028 rule 0/(match) block in on vio0: 169.1.29.111.29765 > 45.FOO.BAR.IP.23: S 757158343:757158343(0) win 28509
Aug 29 15:59:11.575927 rule 0/(match) block in on vio0: 187.160.235.162.32427 > 45.FOO.BAR.IP.5358: S 22445:22445(0) win 14600 [tos 0x28]
Aug 29 15:59:37.826598 rule 0/(match) block in on vio0: 94.74.81.97.54656 > 45.FOO.BAR.IP.3128: S 2720157526:2720157526(0) win 1024 [tos 0x28]stateful
Aug 29 15:59:37.991171 rule 0/(match) block in on vio0: 94.74.81.97.54656 > 45.FOO.BAR.IP.3128: R 2720157527:2720157527(0) win 1200 [tos 0x28]
Aug 29 16:01:36.990050 rule 0/(match) block in on vio0: 182.18.8.28.23299 > 45.FOO.BAR.IP.445: S 1510146048:1510146048(0) win 16384
```
如果要查看实时日志，可以运行：
```
# tcpdump -n -e -ttt -i pflog0
```
如果你想了解更多信息，可以访问 [PF FAQ](https://www.openbsd.org/faq/pf/) 和 [FreeBSD HANDBOOK](https://www.freebsd.org/doc/handbook/firewalls.html) 以及下面这些 man 页面：
```
# man tcpdump
# man pfctl
# man pf
```
### 关于作者
我是 nixCraft 的创立者，一个经验丰富的系统管理员，同时也是一位 Linux 操作系统/Unix shell 脚本培训师。我在不同的行业与全球客户工作过，包括 IT、教育、国防和空间研究、以及非营利组织。你可以在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft) 或 [Google+](https://plus.google.com/+CybercitiBiz) 上面关注我。
---
via: <https://www.cyberciti.biz/faq/how-to-set-up-a-firewall-with-pf-on-freebsd-to-protect-a-web-server/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
15 个可以节省你时间的命令别名
|
Aarchit Modi
|
https://opensource.com/article/18/8/time-saving-command-line-aliases
|
在你安装的 Linux 发行版中默认就包含了一些别名。
|
/data/attachment/album/201809/15/231004r0e3uicruclm3eiu.jpg.thumb.jpg
|
/data/attachment/album/201809/15/231004r0e3uicruclm3eiu.jpg
| true | false | true |
lujun9972
|
MZqk
|
wxy
| false |
[
"别名",
"alias"
] |
技术
|
{
"viewnum": 5907,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在你安装的 Linux 发行版中默认就包含了一些别名。
| 2018-09-15T23:10:13 | 2018-09-15T23:10:13 | 10,017 |
/article-10017-1.html
|
>
> 在你安装的 Linux 发行版中默认就包含了一些别名。
>
>
>
Linux 命令行别名非常适合帮助你提高工作效率。更好的是，在你安装的 Linux 发行版中默认就包含了一些别名。
这是 Fedora 27 中的命令别名的示例：
这个 `alias` 命令列出了已有的别名。设置别名也十分简单：
```
alias new_name="command"
```
这里有 15 个命令行别名，可以节省你的时间：
1、安装任何应用实用 / 应用程序：
```
alias install="sudo yum install -y"
```
在这里，根据每个用户的偏好，`sudo` 和 `-y` 是可选的：
2、更新系统：
```
alias update="sudo yum update -y"
```
3、升级系统：
```
alias upgrade="sudo yum upgrade -y"
```
4、切换 root 用户：
```
alias root="sudo su -"
```
5、切换到 “user” 用户, 其中 `user` 设置为你的用户名：
```
alias user="su user"
```
6、显示列出所有可用端口、状态还有 IP：
```
alias myip="ip -br -c a"
```
7、`ssh` 到你的服务器 `myserver`：
```
alias myserver="ssh user@my_server_ip”
```
8、列出系统中所有进程：
```
alias process="ps -aux"
```
9、检查系统的服务状态：
```
alias sstatus="sudo systemctl status"
```
10、重启系统服务：
```
alias srestart="sudo systemctl restart"
```
11、按名称杀死进程：
```
alias kill="sudo pkill"
```
12、显示系统系统总使用内存和空闲内存 ：
```
alias mem="free -h"
```
13、显示系统 CPU 框架结构、CPU 数量、线程数等：
```
alias cpu="lscpu"
```
14、显示系统总磁盘大小：
```
alias disk="df -h"
```
15、显示当前系统 Linux 发行版本（适用于 CentOS、Fedora 和 Red Hat)：
```
alias os="cat /etc/redhat-release"
```
---
via: <https://opensource.com/article/18/8/time-saving-command-line-aliases>
作者：[Aarchit Modi](https://opensource.com/users/architmodi) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MZqk](https://github.com/MZqk) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux 中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 上检查一个软件包的详细信息
|
Prakash Subramanian
|
https://www.2daygeek.com/how-to-view-detailed-information-about-a-package-in-linux/
|
这篇短文将用尽可能简单的方式帮你从随包自带的总结和描述中了解该包的用法。按你所使用的 Linux 发行版的不同，运行下面相应的命令，你能得到你所使用的发行版下的包的详细信息。
|
/data/attachment/album/201809/16/130119o69ayamb9p5yierr.jpg.thumb.jpg
|
/data/attachment/album/201809/16/130119o69ayamb9p5yierr.jpg
| true | false | true |
lujun9972
|
davidchenliang
|
wxy
| false |
[
"包管理器",
"软件包"
] |
技术
|
{
"viewnum": 9131,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这篇短文将用尽可能简单的方式帮你从随包自带的总结和描述中了解该包的用法。按你所使用的 Linux 发行版的不同，运行下面相应的命令，你能得到你所使用的发行版下的包的详细信息。
| 2018-09-16T13:01:26 | 2018-09-16T13:01:26 | 10,018 |
/article-10018-1.html
|
我们可以就这个已经被广泛讨论的话题写出大量的文章，大多数情况下，因为各种各样的原因，我们都愿意让<ruby> 包管理器 <rt> package manager </rt></ruby>来帮我们做这些事情。
每个 Linux 发行版都有自己的包管理器，并且每个都有各自有不同的特性，这些特性包括允许用户执行安装新软件包，删除无用的软件包，更新现存的软件包，搜索某些具体的软件包，以及更新整个系统到其最新的状态之类的操作。
习惯于命令行的用户大多数时间都会使用基于命令行方式的包管理器。对于 Linux 而言，这些基于命令行的包管理器有 `yum`、`dnf`、`rpm`、`apt`、`apt-get`、`dpkg`、`pacman` 和 `zypper`。
**推荐阅读**
* [Linux 命令行包管理器列表及其用法](https://www.2daygeek.com/list-of-command-line-package-manager-for-linux/)
* [一个图形化的 Linux 包管理器前端工具](https://www.2daygeek.com/list-of-graphical-frontend-tool-for-linux-package-manager/)
* [如何搜索知道一个软件包是否存在于你的 Linux 发行版](https://www.2daygeek.com/how-to-search-if-a-package-is-available-on-your-linux-distribution-or-not/)
* [如何使用 dnf/yum 配置包管理器在 Linux 上来添加、启用和禁用软件仓库](https://www.2daygeek.com/how-to-add-enable-disable-a-repository-dnf-yum-config-manager-on-linux/)
作为一个系统管理员你应该清楚地知道：安装包来自何方，具体来自哪个软件仓库，包的具体版本，包的大小，版本，包的源代码 URL，包的许可证信息，等等。
这篇短文将用尽可能简单的方式帮你从随包自带的总结和描述中了解该包的用法。按你所使用的 Linux 发行版的不同，运行下面相应的命令，你能得到你所使用的发行版下的包的详细信息。
### YUM 命令：在 RHEL 和 CentOS 系统上获得包的信息
[YUM](https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/) 英文直译是“<ruby> 黄狗更新器–修改版 <rt> Yellowdog Updater, Modified </rt></ruby>”，它是一个开源的基于命令行的包管理器前端实用工具。它被广泛应用在基于 RPM 的系统上，例如：RHEL 和 CentOS。
Yum 是用于在官方发行版仓库以及其他第三方发行版仓库下获取、安装、删除、查询 RPM 包的主要工具。
（LCTT 译注：用 `yum info` 获取 python 包的信息）
```
# yum info python
Loaded plugins: fastestmirror, security
Loading mirror speeds from cached hostfile
* epel: epel.mirror.constant.com
Installed Packages
Name : python
Arch : x86_64
Version : 2.6.6
Release : 66.el6_8
Size : 78 k
Repo : installed
From repo : updates
Summary : An interpreted, interactive, object-oriented programming language
URL : http://www.python.org/
License : Python
Description : Python is an interpreted, interactive, object-oriented programming
: language often compared to Tcl, Perl, Scheme or Java. Python includes
: modules, classes, exceptions, very high level dynamic data types and
: dynamic typing. Python supports interfaces to many system calls and
: libraries, as well as to various windowing systems (X11, Motif, Tk,
: Mac and MFC).
:
: Programmers can write new built-in modules for Python in C or C++.
: Python can be used as an extension language for applications that need
: a programmable interface.
:
: Note that documentation for Python is provided in the python-docs
: package.
:
: This package provides the "python" executable; most of the actual
: implementation is within the "python-libs" package.
```
### YUMDB 命令：查看 RHEL 和 CentOS 系统上的包信息
`yumdb info` 这个命令提供与 `yum info` 相类似的的信息，不过它还额外提供了诸如包校验值、包类型、用户信息（由何人安装）。从 yum 3.2.26 版本后，`yum` 开始在 rpm 数据库外储存额外的信息了（此处如显示 `user` 表明该包由用户安装，而 `dep` 说明该包是被作为被依赖的包而被安装的）。
（LCTT 译注：用 `yumdb info` 来获取 python 包的信息）
```
# yumdb info python
Loaded plugins: fastestmirror
python-2.6.6-66.el6_8.x86_64
changed_by = 4294967295
checksum_data = 53c75a1756e5b4f6564c5229a37948c9b4561e0bf58076bd7dab7aff85a417f2
checksum_type = sha256
command_line = update -y
from_repo = updates
from_repo_revision = 1488370672
from_repo_timestamp = 1488371100
installed_by = 4294967295
reason = dep
releasever = 6
```
### RPM 命令：在 RHEL/CentOS/Fedora 系统上查看包的信息
[RPM](https://www.2daygeek.com/rpm-command-examples/) 英文直译为“<ruby> 红帽包管理器 <rt> Red Hat Package Manager </rt></ruby>”，这是一个在 RedHat 以及其变种发行版（如RHEL、CentOS、Fedora、openSUSE、Megeia）下的功能强大的命令行包管理工具。它能让你轻松的安装、升级、删除、查询以及校验你的系统或服务器上的软件。RPM 文件以 `.rpm` 结尾。RPM 包由它所依赖的软件库以及其他依赖构成，它不会与系统上已经安装的包冲突。
（LCTT 译注：用 `rpm -qi` 查询 nano 包的具体信息）
```
# rpm -qi nano
Name : nano Relocations: (not relocatable)
Version : 2.0.9 Vendor: CentOS
Release : 7.el6 Build Date: Fri 12 Nov 2010 02:18:36 AM EST
Install Date: Fri 03 Mar 2017 08:57:47 AM EST Build Host: c5b2.bsys.dev.centos.org
Group : Applications/Editors Source RPM: nano-2.0.9-7.el6.src.rpm
Size : 1588347 License: GPLv3+
Signature : RSA/8, Sun 03 Jul 2011 12:46:50 AM EDT, Key ID 0946fca2c105b9de
Packager : CentOS BuildSystem
URL : http://www.nano-editor.org
Summary : A small text editor
Description :
GNU nano is a small and friendly text editor.
```
### DNF 命令：在 Fedora 系统上查看包信息
[DNF](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/) 指“<ruby> 时髦版的 Yum <rt> Dandified yum </rt></ruby>”，我们也可以认为 DNF 是下一代的 yum 包管理器（Yum 的一个分支），它在后台使用了 hawkey/libsolv 库。Aleš Kozumplík 在Fedora 18 上开始开发 DNF，在 Fedora 22 上正式最后发布。 `dnf` 命令用来在 Fedora 22 及以后的系统上安装、更新、搜索以及删除包。它能自动的解决包安装过程中的包依赖问题。
（LCTT 译注： 用 `dnf info` 查看 tilix 包信息）
```
$ dnf info tilix
Last metadata expiration check: 27 days, 10:00:23 ago on Wed 04 Oct 2017 06:43:27 AM IST.
Installed Packages
Name : tilix
Version : 1.6.4
Release : 1.fc26
Arch : x86_64
Size : 3.6 M
Source : tilix-1.6.4-1.fc26.src.rpm
Repo : @System
From repo : @commandline
Summary : Tiling terminal emulator
URL : https://github.com/gnunn1/tilix
License : MPLv2.0 and GPLv3+ and CC-BY-SA
Description : Tilix is a tiling terminal emulator with the following features:
:
: - Layout terminals in any fashion by splitting them horizontally or vertically
: - Terminals can be re-arranged using drag and drop both within and between
: windows
: - Terminals can be detached into a new window via drag and drop
: - Input can be synchronized between terminals so commands typed in one
: terminal are replicated to the others
: - The grouping of terminals can be saved and loaded from disk
: - Terminals support custom titles
: - Color schemes are stored in files and custom color schemes can be created by
: simply creating a new file
: - Transparent background
: - Supports notifications when processes are completed out of view
:
: The application was written using GTK 3 and an effort was made to conform to
: GNOME Human Interface Guidelines (HIG).
```
### Zypper 命令：在 openSUSE 系统上查看包信息
[zypper](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/) 是一个使用 libzypp 库的命令行包管理器。`zypper` 提供诸如软件仓库访问，安装依赖解决，软件包安装等等功能。
（LCTT 译注： 用 `zypper info` 查询 nano 包的信息）
```
$ zypper info nano
Loading repository data...
Reading installed packages...
Information for package nano:
-----------------------------
Repository : Main Repository (OSS)
Name : nano
Version : 2.4.2-5.3
Arch : x86_64
Vendor : openSUSE
Installed Size : 1017.8 KiB
Installed : No
Status : not installed
Source package : nano-2.4.2-5.3.src
Summary : Pico editor clone with enhancements
Description :
GNU nano is a small and friendly text editor. It aims to emulate
the Pico text editor while also offering a few enhancements.
```
### Pacman 命令：在 ArchLinux 及 Manjaro 系统上查看包信息
[Pacman](https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/) 意即<ruby> 包管理器 <rt> package manager </rt></ruby>实用工具。`pacman` 是一个用于安装、构建、删除、管理 Arch Linux 上包的命令行工具。它后端使用 libalpm（Arch Linux package Manager（ALPM）库）来完成所有功能。
（LCTT 译注： 用 `pacman -Qi` 来查询 bash 包信息）
```
$ pacman -Qi bash
Name : bash
Version : 4.4.012-2
Description : The GNU Bourne Again shell
Architecture : x86_64
URL : http://www.gnu.org/software/bash/bash.html
Licenses : GPL
Groups : base
Provides : sh
Depends On : readline>=7.0 glibc ncurses
Optional Deps : bash-completion: for tab completion
Required By : autoconf automake bison bzip2 ca-certificates-utils db
dhcpcd diffutils e2fsprogs fakeroot figlet findutils
flex freetype2 gawk gdbm gettext gmp grub gzip icu
iptables keyutils libgpg-error libksba libpcap libpng
libtool lvm2 m4 man-db mkinitcpio nano neofetch nspr
nss openresolv os-prober pacman pcre pcre2 shadow
systemd texinfo vte-common which xdg-user-dirs xdg-utils
xfsprogs xorg-mkfontdir xorg-xpr xz
Optional For : None
Conflicts With : None
Replaces : None
Installed Size : 7.13 MiB
Packager : Jan Alexander Steffens (heftig)
Build Date : Tue 14 Feb 2017 01:16:51 PM UTC
Install Date : Thu 24 Aug 2017 06:08:12 AM UTC
Install Reason : Explicitly installed
Install Script : No
Validated By : Signature
```
### apt-cache 命令：在 Debian/Ubuntu/Mint 系统上查看包信息
[apt-cache](https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/) 命令能显示 apt 内部数据库中的大量信息。这些信息是从 `sources.list` 中的不同的软件源中搜集而来，因此从某种意义上这些信息也可以被认为是某种缓存。这些信息搜集工作是在运行 `apt update` 命令时执行的。
（LCTT 译注：用管理员权限查询 apache2 包的信息）
```
$ sudo apt-cache show apache2
Package: apache2
Priority: optional
Section: web
Installed-Size: 473
Maintainer: Ubuntu Developers
Original-Maintainer: Debian Apache Maintainers
Architecture: amd64
Version: 2.4.12-2ubuntu2
Replaces: apache2.2-common
Provides: httpd, httpd-cgi
Depends: lsb-base, procps, perl, mime-support, apache2-bin (= 2.4.12-2ubuntu2), apache2-utils (>= 2.4), apache2-data (= 2.4.12-2ubuntu2)
Pre-Depends: dpkg (>= 1.17.14)
Recommends: ssl-cert
Suggests: www-browser, apache2-doc, apache2-suexec-pristine | apache2-suexec-custom, ufw
Conflicts: apache2.2-common (<< 2.3~)
Filename: pool/main/a/apache2/apache2_2.4.12-2ubuntu2_amd64.deb
Size: 91348
MD5sum: ab0ee0b0d1c6b3d19bd87aa2a9537125
SHA1: 350c9a1a954906088ed032aebb77de3d5bb24004
SHA256: 03f515f7ebc3b67b050b06e82ebca34b5e83e34a528868498fce020bf1dbbe34
Description-en: Apache HTTP Server
The Apache HTTP Server Project's goal is to build a secure, efficient and
extensible HTTP server as standards-compliant open source software. The
result has long been the number one web server on the Internet.
.
Installing this package results in a full installation, including the
configuration files, init scripts and support scripts.
Description-md5: d02426bc360345e5acd45367716dc35c
Homepage: http://httpd.apache.org/
Bugs: https://bugs.launchpad.net/ubuntu/+filebug
Origin: Ubuntu
Supported: 9m
Task: lamp-server, mythbuntu-frontend, mythbuntu-desktop, mythbuntu-backend-slave, mythbuntu-backend-master, mythbuntu-backend-master
```
### APT 命令：查看 Debian/Ubuntu/Mint 系统上的包信息
[APT](https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/) 意为<ruby> 高级打包工具 <rt> Advanced Packaging Tool </rt></ruby>，就像 DNF 将如何替代 YUM 一样，APT 是 apt-get 的替代物。它功能丰富的命令行工具包括了如下所有命令的功能如 `apt-cache`、`apt-search`、`dpkg`、`apt-cdrom`、`apt-config`、`apt-key` 等等，我们可以方便的通过 `apt` 来安装 `.dpkg` 包，但是我们却不能通过 `apt-get` 来完成这一点，还有一些其他的类似的功能也不能用 `apt-get` 来完成，所以 `apt-get` 因为没有解决上述功能缺乏的原因而被 `apt` 所取代。
（LCTT 译注： 用 `apt show` 查看 nano 包信息）
```
$ apt show nano
Package: nano
Version: 2.8.6-3
Priority: standard
Section: editors
Origin: Ubuntu
Maintainer: Ubuntu Developers
Original-Maintainer: Jordi Mallach
Bugs: https://bugs.launchpad.net/ubuntu/+filebug
Installed-Size: 766 kB
Depends: libc6 (>= 2.14), libncursesw5 (>= 6), libtinfo5 (>= 6)
Suggests: spell
Conflicts: pico
Breaks: nano-tiny (<< 2.8.6-2)
Replaces: nano-tiny (<< 2.8.6-2), pico
Homepage: https://www.nano-editor.org/
Task: standard, ubuntu-touch-core, ubuntu-touch
Supported: 9m
Download-Size: 222 kB
APT-Manual-Installed: yes
APT-Sources: http://in.archive.ubuntu.com/ubuntu artful/main amd64 Packages
Description: small, friendly text editor inspired by Pico
GNU nano is an easy-to-use text editor originally designed as a replacement
for Pico, the ncurses-based editor from the non-free mailer package Pine
(itself now available under the Apache License as Alpine).
.
However, GNU nano also implements many features missing in pico, including:
- undo/redo
- line numbering
- syntax coloring
- soft-wrapping of overlong lines
- selecting text by holding Shift
- interactive search and replace (with regular expression support)
- a go-to line (and column) command
- support for multiple file buffers
- auto-indentation
- tab completion of filenames and search terms
- toggling features while running
- and full internationalization support
```
### dpkg 命令：查看Debian/Ubuntu/Mint系统上的包信息
[dpkg](https://www.2daygeek.com/dpkg-command-to-manage-packages-on-debian-ubuntu-linux-mint-systems/) 意指 <ruby> Debian 包管理器 <rt> Debian package manager </rt></ruby>。`dpkg` 是用于 Debian 系统上安装、构建、移除以及管理 Debian 包的命令行工具。`dpkg` 使用 `aptitude`（因为它更为主流及用户友好）作为前端工具来完成所有的功能。其他的工具如`dpkg-deb` 和 `dpkg-query` 使用 `dpkg` 做为前端来实现功能。尽管系统管理员还是时不时会在必要时使用 `dpkg` 来完成一些软件安装的任务，他大多数情况下还是会因为 `apt`、`apt-get` 以及 `aptitude` 的健壮性而使用后者。
（LCTT 译注： 用 `dpkg -s` 查看 python 包的信息）
```
$ dpkg -s python
Package: python
Status: install ok installed
Priority: optional
Section: python
Installed-Size: 626
Maintainer: Ubuntu Developers
Architecture: amd64
Multi-Arch: allowed
Source: python-defaults
Version: 2.7.14-2ubuntu1
Replaces: python-dev (<< 2.6.5-2)
Provides: python-ctypes, python-email, python-importlib, python-profiler, python-wsgiref
Depends: python2.7 (>= 2.7.14-1~), libpython-stdlib (= 2.7.14-2ubuntu1)
Pre-Depends: python-minimal (= 2.7.14-2ubuntu1)
Suggests: python-doc (= 2.7.14-2ubuntu1), python-tk (>= 2.7.14-1~)
Breaks: update-manager-core (<< 0.200.5-2)
Conflicts: python-central (<< 0.5.5)
Description: interactive high-level object-oriented language (default version)
Python, the high-level, interactive object oriented language,
includes an extensive class library with lots of goodies for
network programming, system administration, sounds and graphics.
.
This package is a dependency package, which depends on Debian's default
Python version (currently v2.7).
Homepage: http://www.python.org/
Original-Maintainer: Matthias Klose
```
我们也可使用 `dpkg` 的 `-p` 选项，这个选项提供和 `dpkg -s` 相类似的信息，但是它还提供了包的校验值和包类型。
（LCTT 译注： 用 `dpkg -p` 查看 python3 包的信息）
```
$ dpkg -p python3
Package: python3
Priority: important
Section: python
Installed-Size: 67
Origin: Ubuntu
Maintainer: Ubuntu Developers
Bugs: https://bugs.launchpad.net/ubuntu/+filebug
Architecture: amd64
Multi-Arch: allowed
Source: python3-defaults
Version: 3.6.3-0ubuntu2
Replaces: python3-minimal (<< 3.1.2-2)
Provides: python3-profiler
Depends: python3.6 (>= 3.6.3-1~), libpython3-stdlib (= 3.6.3-0ubuntu2), dh-python
Pre-Depends: python3-minimal (= 3.6.3-0ubuntu2)
Suggests: python3-doc (>= 3.6.3-0ubuntu2), python3-tk (>= 3.6.3-1~), python3-venv (>= 3.6.3-0ubuntu2)
Filename: pool/main/p/python3-defaults/python3_3.6.3-0ubuntu2_amd64.deb
Size: 8712
MD5sum: a8bae494c6e5d1896287675faf40d373
Description: interactive high-level object-oriented language (default python3 version)
Original-Maintainer: Matthias Klose
SHA1: 2daec885cea7d4dc83c284301c3bebf42b23e095
SHA256: 865e509c91d2504a16c4b573dbe27e260c36fceec2add3fa43a30c1751d7e9bb
Homepage: http://www.python.org/
Task: minimal, ubuntu-core, ubuntu-core
Description-md5: 950ebd8122c0a7340f0a740c295b9eab
Supported: 9m
```
### aptitude 命令：查看 Debian/Ubuntu/Mint 系统上的包信息
`aptitude` 是 Debian GNU/Linux 包管理系统的文本界面。它允许用户查看已安装的包的列表，以及完成诸如安装、升级、删除包之类的包管理任务。这些管理行为也能从图形接口来执行。
（LCTT 译注： 用 `aptitude show` 查看 htop 包信息）
```
$ aptitude show htop
Package: htop
Version: 2.0.2-1
State: installed
Automatically installed: no
Priority: optional
Section: universe/utils
Maintainer: Ubuntu Developers
Architecture: amd64
Uncompressed Size: 216 k
Depends: libc6 (>= 2.15), libncursesw5 (>= 6), libtinfo5 (>= 6)
Suggests: lsof, strace
Conflicts: htop:i386
Description: interactive processes viewer
Htop is an ncursed-based process viewer similar to top, but it allows one to scroll the list vertically and horizontally to see all processes and their full command lines.
Tasks related to processes (killing, renicing) can be done without entering their PIDs.
Homepage: http://hisham.hm/htop/
```
---
via: <https://www.2daygeek.com/how-to-view-detailed-information-about-a-package-in-linux/>
作者：[Prakash Subramanian](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[DavidChenLiang](https://github.com/davidchenliang) 校对：[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/2018/3/how-encrypt-files-within-file-manager
|
许多 Linux 桌面版包含了简易的加密和解密文件的功能，如果这种功能没有内置，那么也是很容易添加的。
|
/data/attachment/album/201809/16/220457r2jw0aj9jd9jddcy.jpg.thumb.jpg
|
/data/attachment/album/201809/16/220457r2jw0aj9jd9jddcy.jpg
| true | false | true |
Auk7f7
|
wxy
| false |
[
"GnuPG",
"加密"
] |
桌面应用
|
{
"viewnum": 5777,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
许多 Linux 桌面版包含了简易的加密和解密文件的功能，如果这种功能没有内置，那么也是很容易添加的。
| 2018-09-16T22:04:54 | 2018-09-16T22:04:54 | 10,019 |
/article-10019-1.html
|
Linux 桌面版和服务器版具有卓越的安全性。然而这并不意味着你可以放松警惕。你应该一直认为你的数据总是很快就会被破坏。也就是说，你可能需要使用各种加密工具。比如 GnuPG，它可以让你加密和解密文件等更多功能。GnuPG 的一个问题是一些用户不想在命令行输入那么复杂的命令。如果是这样的话，你可以转向桌面文件管理器。许多 Linux 桌面版包含了简易的加密和解密文件的功能，如果这种功能没有内置，那么也是很容易添加的。
我将引导你完成从三个流行的 Linux 文件管理器中对文件进行加密和解密过程：
* Nautilus （即 GNOME Files）
* Dolphin
* Thunar
### 安装 GnuPG
在我们讨论如何处理这个问题之前，我们必须确保你的系统包含了必要的基本组件 —— [GnuPG](https://www.gnupg.org/)。大多数发行版本都包含 GnuPG。 在某些偶然情况下，你使用的是没有自带 GnuPG 的发行版，以下是安装方法：
* 基于 Ubuntu 的发行版： `sudo apt install gnupg`
* 基于 Fedora 的发行版： `sudo yum install gnupg`
* openSUSE： `sudo zypper in gnupg`
* 基于 Arch 的发行版：`sudo pacman -S gnupg`
无论你是刚刚安装了 GnuPG，还是默认安装的，你都必须创建一个 GPG 密钥才能使用。每个桌面版都使用不同的 GUI 工具完成这个工作（或者甚至根本没有包含一个完成这个任务的 GUI 工具），所以让我们从命令行中创建这个密钥。打开终端窗口并输入以下指令：
```
gpg --gen-key
```
然后，你将被要求回答以下问题。除非你有充分的理由，否则你可以接受默认值：
* 你想要哪种密钥？
* 你想要多长的密钥？
* 密钥有效期？
一旦你回答了这些问题，输入 `y` 来表示答案是正确的。接下来你需要提供以下信息：
* 真实姓名。
* Email 地址。
* 备注。
完成上述操作后，然后在提示的时候输入 `O` （即 ok）。然后，你将被要求为新密钥输入一个密码。一旦系统收集到了足够的熵（你需要在桌面上做一些工作才能做到这一点，LCTT 译注：比如随便敲击键盘），你的密钥就会被创建，然后你就可以开始工作了。
让我们看看如何从文件管理器中加密/解密文件：
### Nautilus
让我们从默认的 GNOME 文件管理器开始，因为它是最简单的。Nautilus 不需要额外安装什么或额外的工作就可以从精心设计的界面内加密/解密文件。一旦你创建完 gpg 密钥后，就可以打开文件管理器，导航到包含要加密的文件的目录，右键单击要加密的文件，然后从菜单中选择 “Encrypt” （图1）。
*图1：从 Nautilus 中加密文件。*
你将被要求选择一个收件人（或者收件人列表 —— 图2）。注意：收件人将是那些你已经导入了公钥的用户。选择所需的密钥，然后从签名信息下拉列表中选择你的密钥（电子邮件地址）。
*图2：选择收件人和签名者。*
注意：你还可以选择仅使用密码来加密文件。如果文件将保留在你的本地机器上，这一点非常重要（稍后将详细介绍）。一旦你设置好加密后，单击 “OK” 并（在提示时）输入 gpg 密钥的密码。文件将被加密（现在文件名以 .gpg 结尾）并保存在工作目录中。现在你可以将加密后的文件发送给在加密过程中已选择的收件人。
比如说（有你的公钥的）某人已经给你发送了一个加密文件。保存该文件，打开文件管理器，导航到该文件所在的目录，右击这个加密文件，选择 “Open With Decrypt File”，给文件一个新名称（不带 .gpg 的扩展名），然后单击“Save”。当提示时，输入你的 gpg 密钥的密码，该文件就会被解密并准备使用。
### Dolphin
在 KDE 前端，必须安装一个软件包才能使用 Dolphin 文件管理器进行加密/解密。 登录到你的 KDE 桌面，打开终端窗口，然后输入以下命令（我正在使用 Neon 进行演示。如果你的发行版不是基于 Ubuntu 的，则必须相应地更改命令）：
```
sudo apt install kgpg
```
安装完毕后，注销并重新登录 KDE 桌面。 你可以打开 Dolphin 并右键单击要加密的文件。 由于这是你第一次使用 kgpg，因此你必须完成快速设置向导（不言自明）。当完成该向导后，你可以返回该文件，右键单击它（图3），然后选择 Encrypt File。
*图3：在 Dolphin 中加密文件。*
系统将提示你选择用于加密的密钥（图4）。 进行选择并单击 “OK”。 该文件将被加密，而且你已准备好将其发送给收件人。
注意：使用 KDE 的 Dolphin 文件管理器市，你无法仅使用密码加密。
*图4：选择要加密的收件人。*
如果你收到来自有你的公钥的用户的加密文件（或者你有一个自己加密的文件），请打开 Dolphin，导航到相关文件，双击该文件，为该文件指定一个新名称 ，键入加密密码并单击 “OK”。 你现在可以读取到新解密的文件。 如果你使用自己的密钥加密了该文件，则不会提示你键入密码（因为它已经被存储了）。
### Thunar
Thunar 文件管理器有点棘手。 没有任何额外的软件包可供安装；相反，你需要为了加密创建新的自定义操作。完成此操作后，你将能够在文件管理器中执行此操作。
要创建自定义操作，请打开 Thunar 文件管理器，然后单击 “Edit > Configure Custom Actions”。 在所得到的窗口中，单击 “+” 按钮（图5）并为加密操作输入以下内容：
* 名称：加密
* 描述：文件加密
* 命令：`gnome-terminal -x gpg --encrypt --recipient ％f`
单击 “OK” 以保存此操作。
*图5：在Thunar中创建自定义操作。*
注意：如果 gnome-terminal 不是你的默认终端，请替换该命令以打开你的默认终端。
你还可以创建仅使用密码（而非密钥）加密的操作。 为此，该操作的详细动作将会是以下内容：
* 名称：加密密码
* 说明：仅使用密码加密
* 命令：`gnome-terminal -x gpg -c ％f`
你不需要为解密过程创建一个自定义操作，因为 Thunar 已经知道如何处理一个加密文件。 要解密文件，只需（在 Thunar 中）右键单击它，选择 “Open With Decrypt File”，为解密文件命名，然后（在提示时）键入加密密码。 Viola，你的加密文件已被解密并可以使用。
### 一个警告
请注意：如果你使用自己的密钥加密自己的文件，则无需输入加密密码来解密它们（因为你的公钥已存储）。 但是，如果你收到（拥有你的公钥的）其他人的文件，则需要输入你的密码。 如果你想要存储自己的加密文件，而不是使用密钥来加密它们，请使用仅使用密码加密。 Nautilus 和Thunar（但不是 KDE）可以做到这一点。 通过选择密码加密（通过密钥加密），当你解密文件时，它将始终提示你输入密码。
### 其他文件管理器
还有很多其它的文件管理器，它们中的一些可以使用加密，有些则不能。 你很有可能正在使用这三种工具中的一种，因此不仅可以将加密 / 解密添加到上下文菜单，而且是非常容易。 尝试一下，看看它是否会使加密和解密的过程变得更容易。
从 Linux 基金会和 edX 免费提供的[“Linux 介绍”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程了解更多关于 Linux 的信息。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/3/how-encrypt-files-within-file-manager>
作者：[JACK WALLEN](https://www.linux.com/users/jlwallen) 译者：[Auk7f7](https://github.com/Auk7f7) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
8 个用于有效地管理进程的 Linux 命令
|
Alan Formy-duval
|
https://opensource.com/article/18/9/linux-commands-process-management
|
通过这些关键的命令来全程管理你的应用。
|
/data/attachment/album/201809/16/225342dggc8idpid9mpp85.png.thumb.jpg
|
/data/attachment/album/201809/16/225342dggc8idpid9mpp85.png
| true | false | true |
lujun9972
|
heguangzhi
|
wxy
| false |
[
"进程"
] |
技术
|
{
"viewnum": 7554,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过这些关键的命令来全程管理你的应用。
| 2018-09-16T22:53:23 | 2018-09-16T22:53:23 | 10,020 |
/article-10020-1.html
|
>
> 通过这些关键的命令来全程管理你的应用。
>
>
>
一般来说，应用程序进程的生命周期有三种主要状态：启动、运行和停止。如果我们想成为称职的管理员，每个状态都可以而且应该得到认真的管理。这八个命令可用于管理进程的整个生命周期。
### 启动进程
启动进程的最简单方法是在命令行中键入其名称，然后按回车键。如果要启动 Nginx web 服务器，请键入 `nginx` 。也许您只是想看看其版本。
```
alan@workstation:~$ nginx
alan@workstation:~$ nginx -v
nginx version: nginx/1.14.0
```
### 查看您的可执行路径
以上启动进程的演示是假设可执行文件位于您的可执行路径中。理解这个路径是可靠地启动和管理进程的关键。管理员通常会为他们想要的目的定制这条路径。您可以使用 `echo $PATH` 查看您的可执行路径。
```
alan@workstation:~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
```
#### WHICH
使用 `which` 命令查看可执行文件的完整路径。
```
alan@workstation:~$ which nginx
/opt/nginx/bin/nginx
```
我将使用流行的 web 服务器软件 Nginx 作为我的例子。假设安装了 Nginx。如果执行 `which nginx` 的命令什么也不返回，那么是找不到 Nginx 了，因为它只搜索您指定的可执行路径。有三种方法可以补救一个进程不能简单地通过名字启动的情况。首先是键入完整路径 —— 虽然，我不情愿输入全部路径，您会吗？
```
alan@workstation:~$ /home/alan/web/prod/nginx/sbin/nginx -v
nginx version: nginx/1.14.0
```
第二个解决方案是将应用程序安装在可执行文件路径中的目录中。然而，这有时可能是办不到的，特别是如果您没有 root 权限。
第三个解决方案是更新您的可执行路径环境变量，包括要使用的特定应用程序的安装目录。这个解决方案是与 shell 相关的。例如，Bash 用户需要在他们的 `.bashrc` 文件中编辑 `PATH=` 行。
```
PATH="$HOME/web/prod/nginx/sbin:$PATH"
```
现在，重复您的 `echo` 和 `which` 命令或者尝试检查版本。容易多了！
```
alan@workstation:~$ echo $PATH
/home/alan/web/prod/nginx/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
alan@workstation:~$ which nginx
/home/alan/web/prod/nginx/sbin/nginx
alan@workstation:~$ nginx -v
nginx version: nginx/1.14.0
```
### 保持进程运行
#### NOHUP
注销或关闭终端时，进程可能不会继续运行。这种特殊情况可以通过在要使用 `nohup` 命令放在要运行的命令前面让进程持续运行。此外，附加一个`&` 符号将会把进程发送到后台，并允许您继续使用终端。例如，假设您想运行 `myprogram.sh` 。
```
nohup myprogram.sh &
```
`nohup` 会返回运行进程的 PID。接下来我会更多地谈论 PID。
### 管理正在运行的进程
每个进程都有一个唯一的进程标识号 (PID) 。这个数字是我们用来管理每个进程的。我们还可以使用进程名称，我将在下面演示。有几个命令可以检查正在运行的进程的状态。让我们快速看看这些命令。
#### PS
最常见的是 `ps` 命令。`ps` 的默认输出是当前终端中运行的进程的简单列表。如下所示，第一列包含 PID。
```
alan@workstation:~$ ps
PID TTY TIME CMD
23989 pts/0 00:00:00 bash
24148 pts/0 00:00:00 ps
```
我想看看我之前启动的 Nginx 进程。为此，我告诉 `ps` 给我展示每一个正在运行的进程（`-e`）和完整的列表（`-f`）。
```
alan@workstation:~$ ps -ef
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 Aug18 ? 00:00:10 /sbin/init splash
root 2 0 0 Aug18 ? 00:00:00 [kthreadd]
root 4 2 0 Aug18 ? 00:00:00 [kworker/0:0H]
root 6 2 0 Aug18 ? 00:00:00 [mm_percpu_wq]
root 7 2 0 Aug18 ? 00:00:00 [ksoftirqd/0]
root 8 2 0 Aug18 ? 00:00:20 [rcu_sched]
root 9 2 0 Aug18 ? 00:00:00 [rcu_bh]
root 10 2 0 Aug18 ? 00:00:00 [migration/0]
root 11 2 0 Aug18 ? 00:00:00 [watchdog/0]
root 12 2 0 Aug18 ? 00:00:00 [cpuhp/0]
root 13 2 0 Aug18 ? 00:00:00 [cpuhp/1]
root 14 2 0 Aug18 ? 00:00:00 [watchdog/1]
root 15 2 0 Aug18 ? 00:00:00 [migration/1]
root 16 2 0 Aug18 ? 00:00:00 [ksoftirqd/1]
alan 20506 20496 0 10:39 pts/0 00:00:00 bash
alan 20520 1454 0 10:39 ? 00:00:00 nginx: master process nginx
alan 20521 20520 0 10:39 ? 00:00:00 nginx: worker process
alan 20526 20506 0 10:39 pts/0 00:00:00 man ps
alan 20536 20526 0 10:39 pts/0 00:00:00 pager
alan 20564 20496 0 10:40 pts/1 00:00:00 bash
```
您可以在上面 `ps` 命令的输出中看到 Nginx 进程。这个命令显示了将近 300 行，但是我在这个例子中缩短了它。可以想象，试图处理 300 行过程信息有点混乱。我们可以将这个输出输送到 `grep`，过滤一下仅显示 nginx。
```
alan@workstation:~$ ps -ef |grep nginx
alan 20520 1454 0 10:39 ? 00:00:00 nginx: master process nginx
alan 20521 20520 0 10:39 ? 00:00:00 nginx: worker process
```
确实更好了。我们可以很快看到，Nginx 有 20520 和 20521 的 PID。
#### PGREP
`pgrep` 命令更加简化单独调用 `grep` 遇到的问题。
```
alan@workstation:~$ pgrep nginx
20520
20521
```
假设您在一个托管环境中，多个用户正在运行几个不同的 Nginx 实例。您可以使用 `-u` 选项将其他人排除在输出之外。
```
alan@workstation:~$ pgrep -u alan nginx
20520
20521
```
#### PIDOF
另一个好用的是 `pidof`。此命令将检查特定二进制文件的 PID，即使另一个同名进程正在运行。为了建立一个例子，我将我的 Nginx 复制到第二个目录，并以相应的路径前缀启动。在现实生活中，这个实例可能位于不同的位置，例如由不同用户拥有的目录。如果我运行两个 Nginx 实例，则`pidof` 输出显示它们的所有进程。
```
alan@workstation:~$ ps -ef |grep nginx
alan 20881 1454 0 11:18 ? 00:00:00 nginx: master process ./nginx -p /home/alan/web/prod/nginxsec
alan 20882 20881 0 11:18 ? 00:00:00 nginx: worker process
alan 20895 1454 0 11:19 ? 00:00:00 nginx: master process nginx
alan 20896 20895 0 11:19 ? 00:00:00 nginx: worker process
```
使用 `grep` 或 `pgrep` 将显示 PID 数字，但我们可能无法辨别哪个实例是哪个。
```
alan@workstation:~$ pgrep nginx
20881
20882
20895
20896
```
`pidof` 命令可用于确定每个特定 Nginx 实例的 PID。
```
alan@workstation:~$ pidof /home/alan/web/prod/nginxsec/sbin/nginx
20882 20881
alan@workstation:~$ pidof /home/alan/web/prod/nginx/sbin/nginx
20896 20895
```
#### TOP
`top` 命令已经有很久的历史了，对于查看运行进程的细节和快速识别内存消耗等问题是非常有用的。其默认视图如下所示。
```
top - 11:56:28 up 1 day, 13:37, 1 user, load average: 0.09, 0.04, 0.03
Tasks: 292 total, 3 running, 225 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.1 us, 0.2 sy, 0.0 ni, 99.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 16387132 total, 10854648 free, 1859036 used, 3673448 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 14176540 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
17270 alan 20 0 3930764 247288 98992 R 0.7 1.5 5:58.22 gnome-shell
20496 alan 20 0 816144 45416 29844 S 0.5 0.3 0:22.16 gnome-terminal-
21110 alan 20 0 41940 3988 3188 R 0.1 0.0 0:00.17 top
1 root 20 0 225564 9416 6768 S 0.0 0.1 0:10.72 systemd
2 root 20 0 0 0 0 S 0.0 0.0 0:00.01 kthreadd
4 root 0 -20 0 0 0 I 0.0 0.0 0:00.00 kworker/0:0H
6 root 0 -20 0 0 0 I 0.0 0.0 0:00.00 mm_percpu_wq
7 root 20 0 0 0 0 S 0.0 0.0 0:00.08 ksoftirqd/0
```
可以通过键入字母 `s` 和您喜欢的更新秒数来更改更新间隔。为了更容易监控我们的示例 Nginx 进程，我们可以使用 `-p` 选项并传递 PID 来调用 `top`。这个输出要干净得多。
```
alan@workstation:~$ top -p20881 -p20882 -p20895 -p20896
Tasks: 4 total, 0 running, 4 sleeping, 0 stopped, 0 zombie
%Cpu(s): 2.8 us, 1.3 sy, 0.0 ni, 95.9 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 16387132 total, 10856008 free, 1857648 used, 3673476 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 14177928 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
20881 alan 20 0 12016 348 0 S 0.0 0.0 0:00.00 nginx
20882 alan 20 0 12460 1644 932 S 0.0 0.0 0:00.00 nginx
20895 alan 20 0 12016 352 0 S 0.0 0.0 0:00.00 nginx
20896 alan 20 0 12460 1628 912 S 0.0 0.0 0:00.00 nginx
```
在管理进程，特别是终止进程时，正确确定 PID 是非常重要。此外，如果以这种方式使用 `top`，每当这些进程中的一个停止或一个新进程开始时，`top` 都需要被告知有新的进程。
### 终止进程
#### KILL
有趣的是，没有 `stop` 命令。在 Linux 中，有 `kill` 命令。`kill` 用于向进程发送信号。最常用的信号是“终止”（`SIGTERM`）或“杀死”（`SIGKILL`）。然而，还有更多。下面是一些例子。完整的列表可以用 `kill -L` 显示。
```
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
```
注意第 9 号信号是 `SIGKILL`，通常，我们会发出比如 `kill -9 20896` 这样的命令。默认信号是 15，这是 `SIGTERM`。请记住，许多应用程序都有自己的停止方法。Nginx 使用 `-s` 选项传递信号，如 `stop` 或 `reload`。通常，我更喜欢使用应用程序的特定方法来停止操作。然而，我将演示用 `kill` 命令来停止 Nginx 进程 20896，然后用 `pgrep` 确认它已经停止。PID 20896 就不再出现。
```
alan@workstation:~$ kill -9 20896
alan@workstation:~$ pgrep nginx
20881
20882
20895
22123
```
#### PKILL
命令 `pkill` 类似于 `pgrep`，因为它可以按名称搜索。这意味着在使用 `pkill` 时必须非常小心。在我的 Nginx 示例中，如果我只想杀死一个 Nginx 实例，我可能不会选择使用它。我可以将 Nginx 选项 `-s stop` 传递给特定的实例来消除它，或者我需要使用 `grep` 来过滤整个 `ps` 输出。
```
/home/alan/web/prod/nginx/sbin/nginx -s stop
/home/alan/web/prod/nginxsec/sbin/nginx -s stop
```
如果我想使用 `pkill`，我可以包括 `-f` 选项，让 `pkill` 过滤整个命令行参数。这当然也适用于 `pgrep`。所以，在执行 `pkill -f` 之前，首先我可以用 `pgrep -a` 确认一下。
```
alan@workstation:~$ pgrep -a nginx
20881 nginx: master process ./nginx -p /home/alan/web/prod/nginxsec
20882 nginx: worker process
20895 nginx: master process nginx
20896 nginx: worker process
```
我也可以用 `pgrep -f` 缩小我的结果。`pkill` 使用相同参数会停止该进程。
```
alan@workstation:~$ pgrep -f nginxsec
20881
alan@workstation:~$ pkill -f nginxsec
```
`pgrep`（尤其是 `pkill`）要记住的关键点是，您必须始终确保搜索结果准确性，这样您就不会无意中影响到错误的进程。
大多数这些命令都有许多命令行选项，所以我总是建议阅读每一个命令的 [man 手册页](https://www.kernel.org/doc/man-pages/)。虽然大多数这些命令都存在于 Linux、Solaris 和 BSD 等平台上，但也有一些不同之处。在命令行工作或编写脚本时，始终测试并随时准备根据需要进行更正。
---
via: <https://opensource.com/article/18/9/linux-commands-process-management>
作者：[Alan Formy-Duval](https://opensource.com/users/alanfdoss) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
i3 窗口管理器入门
|
Ricardo Gerardi
|
https://opensource.com/article/18/8/getting-started-i3-window-manager
|
本篇文章会介绍如何在 Fedora 系统中，安装、配置、使用 i3 瓦片式桌面管理器。
|
/data/attachment/album/201809/17/172829oj2v3k3qjqx5czuv.png.thumb.jpg
|
/data/attachment/album/201809/17/172829oj2v3k3qjqx5czuv.png
| true | false | true |
lujun9972
|
sd886393
|
wxy
| false |
[
"i3",
"GNOME",
"窗口管理器"
] |
桌面应用
|
{
"viewnum": 20598,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10286,
"displayorder": 0
}
] |
本篇文章会介绍如何在 Fedora 系统中，安装、配置、使用 i3 瓦片式桌面管理器。
| 2018-09-17T17:28:23 | 2018-09-17T17:28:23 | 10,021 |
/article-10021-1.html
|
>
> 本篇文章会介绍如何在 Fedora 系统中，安装、配置、使用 i3 瓦片式桌面管理器。
>
>
>
在我的文章 [i3 桌面让 Linux 更好的 5 个理由](https://opensource.com/article/18/8/i3-tiling-window-manager)，我分享了选择 [i3 桌面管理器](https://i3wm.org) 作为一种 Linux 桌面替代方案的最主要五个理由。
在本篇文章中，我将向大家展示，如何在 Fedora 28 上安装与简单配置 i3。
### 1、 安装
首先进入 Fedora 系统中，打开一个终端。使用 `dnf` 来安装需要的软件包，如下：
```
[ricardo@f28i3 ~]$ sudo dnf install -y i3 i3-ipc i3status i3lock dmenu terminator --exclude=rxvt-unicode
Last metadata expiration check: 1:36:15 ago on Wed 08 Aug 2018 12:04:31 PM EDT.
Dependencies resolved.
================================================================================================
Package Arch Version Repository Size
================================================================================================
Installing:
dmenu x86_64 4.8-1.fc28 fedora 33 k
i3 x86_64 4.15-1.fc28 fedora 323 k
i3-ipc noarch 0.1.4-12.fc28 fedora 14 k
i3lock x86_64 2.9.1-2.fc28 fedora 33 k
i3status x86_64 2.12-1.fc28 updates 62 k
terminator noarch 1.91-4.fc28 fedora 570 k
Installing dependencies:
dzen2 x86_64 0.8.5-21.20100104svn.fc28 fedora 60 k
... Skipping dependencies/install messages
Complete!
[ricardo@f28i3 ~]$
```
注意：在这个命令中，我排除了 `rxvt-unicode` 这个包，因为我更喜欢 `terminator` 作为我的终端模拟器。
据用户目前的系统状态，在命令执行过程中可能会安装很多依赖。等待所有的依赖安装完成，之后重启你的电脑。
### 2、 首次登录与初始化
在你的机器重启之后，你便可以第一次体验 i3 了。在 GNOME 显示管理器（GDM）屏幕，选择你的用户名，之后先别着急输密码，点击下方的密码输入框下方的小齿轮，之后选择 i3 而不是 GNOME，像下方这样：
输入你的密码，并点击 “Sign In”。在你第一次登入之后，会先看到 i3 的配置界面：
点击回车键就会在 `$HOME/.config/i3` 生成一个配置文件，之后你可以通过这个配置文件来定制化 i3 的一些行为。
在下一屏，你需要选择你的 `Mod` 键。这一步很关键，因为 `Mod` 键通常都会作为 i3 命令快捷键的发起键。按回车会选择 `Win` 键作为默认的 `Mod` 键。如果你的键盘没有 `Win` 键，用 `Alt` 键做替代，用方向键键选择后按回车键确认。
现在你就登录到了 i3 的系统中。由于 i3 是一个极简的窗口管理器，你会看到一个黑屏窗口，以及屏幕底端显示的状态栏：
接下来，让我们看看 i3 的如何实际使用。
### 3、 基本的快捷键
现在你已经登录到了 i3 会话中，你需要几个基本的快捷键来应对基本的操作。
大多数的 i3 快捷键都会用到之前配置的 `Mod` 键。在下面的例子中，当我提到 `Mod` 键，请根据情况使用你定义的做替换。通常使用 `Win` 键或者 `Alt` 键。
首先，要打开一个终端，可以使用 `Mod+ENTER`。重复打开几个终端，观察 i3 是如何自动将它们在桌面中排列。默认情况下， i3 会在水平的方向分割屏幕；使用 `Mod + v` 来垂直分割，再按 `Mod + h` 会恢复水平分割模式。
当需要启动其他的应用，按 `Mod + d` 来打开 `dmenu`，一个简单的文字应用菜单。默认情况下，`dmenu` 会呈现出所有在你 `$PATH` 中设置的应用。使用方向键来选择你想启动的应用，同时你可以键入应用的名称，来缩小选择的范围，之后按回车键来启动选择的应用。
如果你的应用没有提供退出的方法，你可以使用 i3 来关闭对应的窗口，通过按 `Mod + Shift +q`。注意，你可能会丢失未保存的工作内容。
最后，当你想关闭会话并退出 i3，按 `Mod + Shift +e`。之后会在窗口的上方提示你是否退出。点击 “Yes, exit i3” 退出，或选择 “X” 来取消。
这些就是 i3 中最基本的快捷键，如果想了解更多，请查阅官方[文档](https://i3wm.org/docs/userguide.html#_default_keybindings)。
### 4、 替换 GDM
使用 i3 窗口管理器会降低你操作系统的内存占用；然而，Fedora 依然会使用 GDM 作为登录屏。GDM 会载入几个与 GNOME 相关的库从而占用内存。
如果你想进一步的降低你的内存占用，你可以使用一些更轻量级的显示管理器来替换 GDM，比如 lightdm ：
```
[ricardo@f28i3 ~]$ sudo dnf install -y lightdm
[ricardo@f28i3 ~]$ sudo systemctl disable gdm
Removed /etc/systemd/system/display-manager.service.
[ricardo@f28i3 ~]$ sudo systemctl enable lightdm
Created symlink /etc/systemd/system/display-manager.service -> /usr/lib/systemd/system/lightdm.service.
[ricardo@f28i3 ~]$
```
之后重启你的机器来使用 Lightdm 的登录界面。
现在你可以继续登录并使用 i3了。
---
via: <https://opensource.com/article/18/8/getting-started-i3-window-manager>
作者：[Ricardo Gerardi](https://opensource.com/users/rgerardi) 选题：[lujun9972](https://github.com/lujun9972) 译者：[sd886393](https://github.com/sd886393) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linus Torvalds 宣布无限期休假，开始自我反省……
|
Wxy
|
Linux 内核之父 Linus Torvalds 为其无理咆哮而道歉，并决定离开 Linux 内核项目休息一段时间，学习一下如何与人相处之道。
|
/data/attachment/album/201809/17/211434uq48ceo8idrk8skz.jpg.thumb.jpg
|
/data/attachment/album/201809/17/211434uq48ceo8idrk8skz.jpg
| true | false | false | true |
[
"内核"
] |
新闻
|
{
"viewnum": 9964,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 1649,
"displayorder": 0
},
{
"raid": 10122,
"displayorder": 0
},
{
"raid": 2809,
"displayorder": 1
},
{
"raid": 4032,
"displayorder": 2
},
{
"raid": 4120,
"displayorder": 3
},
{
"raid": 4684,
"displayorder": 4
},
{
"raid": 5134,
"displayorder": 5
},
{
"raid": 5651,
"displayorder": 6
}
] |
Linux 内核之父 Linus Torvalds 为其无理咆哮而道歉，并决定离开 Linux 内核项目休息一段时间，学习一下如何与人相处之道。
| 2018-09-17T21:14:00 | 2018-09-17T21:14:00 | 10,022 |
/article-10022-1.html
|
>
> Linux 内核之父 Linus Torvalds 为其无理咆哮而道歉，并决定离开 Linux 内核项目休息一段时间，学习一下如何与人相处之道。
>
>
>
前一段时间， Linus Torvalds 因为[其个人的苏格兰休假计划](https://www.theregister.co.uk/2018/09/07/maintainers_summit_scotland/)而要将今年的 Linux 内核维护者峰会召开地点从原定的加拿大改到苏格兰。在会议上 Torvalds 招致了社区成员的强烈反对，以至于本次会议也由讨论技术问题，变成了抨击 Torvalds 本人的问题。一些维护者指责他“根本不懂得如何相处”，而由于此次议程变动，也使得很多本应该讨论的技术问题没能付诸讨论。
在昨天的邮件列表当中，Torvalds 在[邮件](https://lkml.org/lkml/2018/9/16/167)中承认其对其他 Linux 内核开发者和贡献者们的“轻率的攻击”是“不专业的，也是不必要的，而且很多回应属于人身攻击。从努力维护好内核更新的角度，他们提出的观点是合情合理的。……我知道这是不对的，我真的感到很抱歉。”
“我也许需要‘照照镜子’了。” Torvalds 表示，“一方面，我终于意识到，我希望不出席每年一度的 Linux 内核维护者峰会的想法是不妥当的，另一方面，我意识到自己一直忽视了社群中的一些相当深思熟虑的观点。”
“我误会了其他人，并且几年来都没有意识到我对形势的判断，导致了社群内的不专业的环境的危害有多么巨大。”
“我需要改变一些我的行为”，他补充说，“我要向那些因为我个人行为而受到伤害，甚至可能完全脱离了内核开发的人道歉。”这不是 Torvalds 第一次为其出言不逊而道歉，之前甚至因为他的无礼而导致一位著名的女性 Linux 内核核心开发人员 Sarah Sharp 的退出，不过这次看起来 Torvalds 是真正开始反省自己，并以一个技术人员的思路寻求“技术”解决方案以解决这个问题。
而上一次 Torvalds 感觉到 Linux 内核开发中的“痛点”，决定自己出手解决这个“技术”问题的后果就是 Git 的产生。
Linus Torvalds 是 Linux 内核的创始人，并从 1991 年开始就一直从事于 Linux 内核的开发和管理。他表示他会从 Linux 内核的开发当中休息一段时间——就像当年为了创建 Git 一样休息一段时间，做做“自我反省”，开发一些像 Git 一样的小工具来解决他的问题。
“我需要休息一段时间，以找到一些解决我在工具和工作流方面的问题的办法”，他接着说，“这不是我要‘撒手不干’了，我不觉得我不想继续维护 Linux 内核了。恰恰相反，我非常想继续做这个我已经做了快三十年的项目。”
“没错，我可能只是要开发一些‘工具’，比如邮件过滤器，这样我下次在邮件里写了脏话，就不会发出去了。因为我是一个工具信徒，我觉得一些问题完全可以通过简单的自动化流程而解决。”
那么，让我们拭目以待，看看 Torvalds 休息的这段时间，内核社区会怎么样，而他又会给我们带来什么变化或惊喜。
|
||||
在 OpenDev 大会上学习 CI/CD
|
Elizabeth K.joseph
|
https://opensource.com/article/18/5/opendev
|
未来的开发工作需要非常精通 CI/CD 流程。
|
/data/attachment/album/201809/17/231756smmq0up0b0m88s90.png.thumb.jpg
|
/data/attachment/album/201809/17/231756smmq0up0b0m88s90.png
| true | false | true |
lujun9972
|
jamelouis
|
wxy
| false |
[
"CI",
"CD"
] |
新闻
|
{
"viewnum": 4953,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
未来的开发工作需要非常精通 CI/CD 流程。
| 2018-09-17T23:17:43 | 2018-09-17T23:17:43 | 10,023 |
/article-10023-1.html
|
>
> 未来的开发工作需要非常精通 CI/CD 流程。
>
>
>
在 2017 年启动后，OpenDev 大会现在已是一个年度活动。在去年 9 月的首届活动上，会议的重点是边缘计算。今年的活动，于 5 月 22 - 23 日举行，会议的重点是持续集成和持续发布 (CI/CD)，并与 OpenStack 峰会一起在温哥华举行。
基于我在 OpenStack 项目的 CI/CD 系统的技术背景和我近期进入容器下的 CI/CD 方面的经验，我被邀请加入 OpenDev CI/CD 计划委员会。今天我经常借助很多开源技术，例如 [Jenkins](https://jenkins.io/)、[GitLab](https://about.gitlab.com/)、[Spinnaker](https://www.spinnaker.io/) 和 [Artifactory](https://jfrog.com/artifactory/) 来讨论 CI/CD 流程。
这次活动对我来说是很激动人心的，因为我们将在这个活动中融合两个开源基础设施理念。首先，我们将讨论可以被任何组织使用的 CI/CD 工具。为此目的，在 [讲演](http://2018.opendevconf.com/schedule/) 中，我们将听到关于开源 CI/CD 工具的使用讲演，一场来自 Boris Renski 的关于 Spinnaker 的讲演，和一场来自 Jim Blair 的关于 [Zuul](https://zuul-ci.org/) 的讲演。同时，讲演会涉及关于开源技术的偏好的高级别话题，特别是那种跨社区的和本身就是开源项目的。从Fatih Degirmenci 和 Daniel Farrel 那里，我们将听到关于在不同社区分享持续发布实践经历，接着 Benjamin Mako Hill 会为我们带来一场关于为什么自由软件需要自由工具的分享。
在分享 CI/CD 相对新颖的特性后，接下来的活动是对话、研讨会和协作讨论的混合组合。当从人们所提交的讲座和研讨会中进行选择，并提出协作讨论主题时，我们希望确保有一个多样灵活的日程表，这样任何参与者都能在 CI/CD 活动进程中发现有趣的东西。
这些讲座会是标准的会议风格，选择涵盖关键主题，如制定 CI/CD 流程，在实践 DevOps 时提升安全性，以及更具体的解决方案，如基于容器关于 Kubernetes 的 [Aptomi](http://aptomi.io/) 和在 ETSI NFV 环境下 CI/CD。这些会话的大部分将会是作为给新接触 CI/CD 或这些特定技术的参与者关于这些话题和理念的简介。
交互式的研讨会会持续相对比较长的时间，参与者将会在思想上得到特定的体验。这些研讨会包括 “[在持续集成任务中的异常检测](https://www.openstack.org/summit/vancouver-2018/summit-schedule/events/21692/anomaly-detection-in-continuous-integration-jobs)”、“[如何安装 Zuul 和配置第一个任务](https://www.openstack.org/summit/vancouver-2018/summit-schedule/events/21693/how-to-install-zuul-and-configure-your-first-jobs)”，和“[Spinnake 101：快速可靠的软件发布](https://www.openstack.org/summit/vancouver-2018/summit-schedule/events/21699/spinnaker-101-releasing-software-with-velocity-and-confidence)”。（注意这些研讨会空间是有限的，所以设立了一个 RSVP 系统。你们将会在会议的链接里找到一个 RSVP 的按钮。)
可能最让我最兴奋的是协作讨论，这些协作讨论占据了一半以上的活动安排。协作讨论的主题由计划委员会选取。计划委员会根据我们在社区里所看到来选取对应的主题。这是“鱼缸”风格式的会议，通常是几个人聚在一个房间里围绕着 CI/CD 讨论某一个主题。
这次会议风格的理念是来自于开发者峰会，最初是由 Ubuntu 社区提出，接着 OpenStack 社区也在活动上采纳。这些协作讨论的主题包含不同的会议，这些会议是关于 CI/CD 基础，可以鼓励跨社区协作的提升举措，在组织里推行 CI/CD 文化，和为什么开源 CI/CD 工具如此重要。采用共享文档来做会议笔记，以确保尽可能的在会议的过程中分享知识。在讨论过程中，提出行动项目也是很常见的，因此社区成员可以推动和所涉及的主题相关的倡议。
活动将以联合总结会议结束。联合总结会议将总结来自协同讨论的关键点和为即将在这个领域工作的参与者指出可选的职业范围。
可以在 [OpenStack 峰会注册页](https://www.eventbrite.com/e/openstack-summit-may-2018-vancouver-tickets-40845826968?aff=VancouverSummit2018) 上注册参加活动。或者可以在温哥华唯一指定售票的会议中心购买活动的入场券，价格是 $199。更多关于票和全部的活动安排见官网 [OpenDev 网站](http://2018.opendevconf.com/)。
我希望你们能够加入我们，并在温哥华渡过令人激动的两天，并且在这两天的活动中学习，协作和在 CI/CD 取得进展。
---
via: <https://opensource.com/article/18/5/opendev>
作者：[Elizabeth K.Joseph](https://opensource.com/users/pleia2) 选题：[lujun9972](https://github.com/lujun9972) 译者：[jamelouis](https://github.com/jamelouis) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 VirtualBox 中安装 Android 系统
|
Ranvir Singh
|
https://linuxhint.com/install_android_virtualbox/
|
你可以在该虚拟机里测试应用程序，也可以使用 Android 的内部功能。
|
/data/attachment/album/201809/18/001443wijtrv00r8sr90b0.png.thumb.jpg
|
/data/attachment/album/201809/18/001443wijtrv00r8sr90b0.png
| true | false | true |
lujun9972
|
jrglinux
|
wxy
| false |
[
"Android",
"VirtualBox"
] |
技术
|
{
"viewnum": 56697,
"commentnum": 6,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "69.43.204.50",
"message": "我下载了两个安卓系统，都是安装完以后直接进入terminal，<br />\r\n请问怎么样进入GUI 图形界面呢？",
"username": "来自美国的 Chrome 75.0|Mac 10.14 用户",
"date": "2019-07-09T05:15:15"
},
{
"postip": "114.242.47.102",
"message": "Android x86, Virtual Box 6.0, 安装完毕了以后，设置 -> 显示 -> 显卡控制器 -> VBoxVGA，并且勾选3D加速，否则不显示GUI",
"username": "来自北京的 Safari 13.0|Mac 10.14 用户",
"date": "2019-11-20T16:26:26"
},
{
"postip": "182.109.192.157",
"message": "重启一次，开机选择第二项回车，进入debug模式<br />\r\n回车输入：mount -o remount,rw /mnt <br />\r\n输入：vi /mnt/grub/menu.lst回车，<br />\r\n按i，进入编辑模式，在第一个启动项，quiet后面加入nomodeset（就第一个AndroidX86 ** RC1下面那行，quiet后面 root前面）<br />\r\n按esc键取消编辑模式，输入：wq回车保存并退出，重启系统即可。（:wq）<br />\r\n重启之后就顺利的进入系统了，",
"username": "来自江西宜春的 Chrome 91.0|Windows 10 用户",
"date": "2021-10-11T13:33:00"
},
{
"postip": "183.216.56.51",
"message": "我这vbox6.1，VBoxVGA和3D加速不能共存，只设置VBoxVGA之后可以进入GUI",
"username": "来自江西南昌的 Chrome 98.0|Windows 10 用户",
"date": "2022-02-05T18:36:27"
},
{
"postip": "66.65.70.83",
"message": "我安装完后重启一直显示 在检测，无进展，尝试您的教程步骤多次，问题依旧，请教",
"username": "来自美国的 Chrome 109.0|Windows 10 用户",
"date": "2023-02-07T07:54:24"
},
{
"postip": "183.199.179.212",
"message": "mac环境，利用virtualbox安装Android x86，只有consle命令界面，如何进入GUI呀？安装有问题？",
"username": "来自河北唐山的 Chrome 111.0|Mac 10.15 用户",
"date": "2023-03-12T17:15:33"
}
] |
[] |
你可以在该虚拟机里测试应用程序，也可以使用 Android 的内部功能。
| 2018-09-18T00:14:00 | 2018-09-18T00:14:00 | 10,024 |
/article-10024-1.html
|
如果你正在开发 Android 应用，也许会遇到小麻烦。诚然，ios 移动开发有 macOS 系统平台为其提供友好便利性， Android 开发仅有支持少部分 Android 系统（其中还包括可穿戴设备系统）的 Android Studio 工具。
毋庸置疑，所有的二进制工具、SDK 工具、开发框架工具以及调试器都会产生大量日志和其他各种文件，使得你的文件系统很混乱。一个有效的解决方法就是在 VirtualBox 中安装 Android 系统，这样还解决了 Android 开发中最为棘手问题之一 —— 设备模拟器。你可以在该虚拟机里测试应用程序，也可以使用 Android 的内部功能。因此，让我们迫不及待的开始吧！
### 准备工作
首先，你需要在你的系统上安装 VirtualBox，可从[这里](https://www.virtualbox.org/wiki/Downloads)下载 Windows 版本、macOS 版本或者各种 Linux 版本的 VitualBox。然后，你需要一个能在 x86 平台运行的 Android 镜像，因为 VirtualBox 为虚拟机提供运行 x86 或者 x86\_64（即 AMD64）平台的功能。
虽然大部分 Android 设备都在 ARM 上运行，但我们依然可以从 [Android on x86 项目](http://www.android-x86.org/) 中获得帮助。这些优秀的开发者已经将 Android 移植到 x86 平台上运行（包括实体机和虚拟机），我们可以下载最新版本的 Android 7.1。你也可以用之前更为稳定的版本，本文写作时最新稳定版是 Android 6.0。
### 创建 VM 虚拟机
打开 VirtualBox，单击左上角的 “新建” 按钮，在弹出的窗口中选择 “类型：Linux” ，然后根据下载的 ISO 镜像来确定版本，x86 对应 “32-bit”，x86\_64 对应 “64-bit”，此处选择 “Linux 2.6 / 3.x / 4.x (64-bit)”。
RAM 大小设置为 2 GB 到你系统能提供的最大内存之间。如果你想模拟真实的使用环境你可以设置 6 GB RAM 和 32 GB ROM。
创建完成后，你还需要做一些设置，添加更多的处理器核心，提高开机显示内存。在 VM 上打开设置选项，“设置 -> 系统 -> 处理器”，如果硬件条件允许，可以多分配一些处理器。
在 “设置 -> 显示 -> 显存大小” 中，你可以分配一大块内存并开启 3D 加速功能。
现在我们可以启动 VM 虚拟机了。
### 安装 Android
首次启动 VM 虚拟机，VirtualBox 会提示你需要提供启动媒介，选择之前下载好的Android 镜像。
下一步，如果想长时间使用 Android，选择 “Installation” 选项，你也可以选择 Live 模式体验 Android 环境。
按回车键。
#### 分区
分区是通过文本界面操作，并没有友好的 GUI 界面，所以每个操作都需要小心对待。例如，在第一屏中还没有创建分区并且只检测到原始（虚拟）硬盘时显示如下。
红色字母 `C` 和 `D` 表明 `C` 开头选项可以创建或者修改分区，`D` 开头选项可以检测设备。你可以选择 `D` 开头选项，然后它就会检测硬盘，也可不进行这步操作，因为在启动的时候它会自动检测。
我们选择 `C` 开头选项，在虚拟盘中创建分区。官方不推荐使用 GPT 格式，所以我们选择 “No” 并按回车键。
现在你被引导到 fdisk 工具页面。
为了简洁起见，我们就只创建一个较大的分区，使用方向键来选择 “New” ，然后选择 “Primary”，按回车键以确认。
分区大小系统已经为你计算好了，按回车键确认。
这个分区就是 Android 系统所在的分区，所以需要它是可启动的。选择 “Bootable”，然后按回车键（上方表格中 “Flags” 标志下面会出现 “boot” 标志），进一步，选择 “Write” 选项，保存刚才的操作记录并写入分区表。
现在你可以选择退出分区工具，然后继续安装过程。
#### 文件系统格式化为 EXT4 并安装 Android
在“Choose Partition”分区页面上会出现一个刚刚我们创建的分区，选择它并点击“OK”进入。
在下一个菜单中选择 Ext4 作为实际的文件系统，在下一页中选择 “Yes” 然后格式化开始。会提示是否安装 GRUB 引导工具以及是否允许在目录 `/system` 进行读写，都选择 “Yes” 。现在，安装进程开始。
安装完成后，当系统提示可以重启的时候你可以安全地重启系统。在重启之前，你可以先关机，然后在 VitualBox 的 “设置 -> 存储” 中检查 Android iso 镜像是否还连接在虚拟机上，如果在，将它移除。
移除安装媒介并保存修改，再去启动 VM 虚拟机。
#### 运行 Android
在 GRUB 引导界面，有调试模式和普通模式的选项。我们选择默认选项，如下图所示。
如果一切正常，你将会看到如下界面：
如今的 Android 系统使用触摸交互而不是鼠标。不过 Android-x86 平台提供了鼠标操作支持，但开始时可能需要方向键来辅助操作。
移动到”let’s go“按钮并按下回车键。选择 “Set up as new” 选项，回车确认。
在提示用谷歌账户登陆之前，系统检查更新并检测设备信息。你可以跳过这一步，直接去设置日期和时间、用户名等。
还有一些其他的选项，和让你设置一个新的 Android 设备类似。选择 “I Agree” 选项同意有关更新、服务等的相应的选项，当然谷歌的服务条款是不得不同意的。
在这之后，因为它是个虚拟机，所以可能需要添加额外的 email 账户来设置 “On-body detection”，大部分的选项对我们来说都没有多大作用，因此可以选择 ”All Set“。
接下来，它会提示你选择主屏应用，这个根据个人需求选择。现在我们进入了一个虚拟的 Android 系统。
如果你需要在 VM 做一些交互测试，有个可触摸屏幕会提供很大的方便，因为那样才更接近真实使用环境。
希望这篇教程会给你带来帮助。
---
via: <https://linuxhint.com/install_android_virtualbox/>
作者：[Ranvir Singh](https://linuxhint.com/author/sranvir155/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[jrglinux](https://github.com/jrglinux) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
5 个在 Fedora 上管理待办事项的程序
|
Ryan Lerch
|
https://fedoramagazine.org/5-tools-to-manage-your-to-do-list-on-fedora/
|
有效管理待办事项（to-do）可以为你的工作效率创造奇迹。
|
/data/attachment/album/201809/18/204131mhz93n92dz0e3wp7.jpg.thumb.jpg
|
/data/attachment/album/201809/18/204131mhz93n92dz0e3wp7.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"to-do"
] |
分享
|
{
"viewnum": 3526,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有效管理待办事项（to-do）可以为你的工作效率创造奇迹。
| 2018-09-18T20:41:00 | 2018-09-18T20:41:00 | 10,025 |
/article-10025-1.html
|
有效管理待办事项（to-do）可以为你的工作效率创造奇迹。有些人更喜欢在文本中保存待办事项，甚至只使用记事本和笔。对于需要更多待办事项功能的用户，他们通常会使用应用程序。在本文中，我们将重点介绍 4 个图形程序和一个基于终端的工具来管理待办事项。
### GNOME To Do
[GNOME To Do](https://wiki.gnome.org/Apps/Todo/) 是专为 GNOME 桌面（Fedora Workstation 的默认桌面）设计的个人任务管理器。GNOME To Do 与其他程序进行比较，它有一系列简洁的功能。
GNOME To Do 提供列表形式的任务组织方式，并能为该列表指定颜色。此外，可以为各个任务分配截止日期和优先级，以及每项任务的注释。此外，GNOME To Do 还支持扩展，能添加更多功能，包括支持 [todo.txt](http://todotxt.org/) 以及与 [todoist](https://en.todoist.com/) 等在线服务同步。
使用软件中心或者在终端中使用下面的命令安装 GNOME To Do：
```
sudo dnf install gnome-todo
```
### Getting things GNOME!
在 GNOME To Do 出现之前，在 GNOME 上追踪任务的首选程序是 [Getting things GNOME!](https://wiki.gnome.org/Apps/GTG) 这个老式的 GNOME 程序采用多窗口布局，能让你同时显示多个任务的细节。GTG 没有任务列表，它能在任务中添加子任务，甚至在子任务中添加子任务。GTG 同样能添加截止日期和开始日期。也可以通过插件同步其他程序和服务。
在软件中心或者在终端中使用下面的命令安装 Getting Things GNOME：
```
sudo dnf install gtg
```
### Go For It!
[Go For It!](http://manuel-kehl.de/projects/go-for-it/) 是一个超级简单的任务管理程序。它能简单地创建一个任务列表，并在完成后标记它们。它不能将任务分组，也不能创建子任务。Go For It! 默认将任务存储为 todo.txt 格式，这能更方便地同步到在线服务或者其他程序中。额外地，Go For It! 包含了一个简单定时器来追踪你在当前任务花费了多少时间。
Go For It! 能在 Flathub 应用仓库中找到。要安装它，只需[启用 Flathub 作为软件源](https://fedoramagazine.org/install-flathub-apps-fedora/)，接着在软件中心中安装。
### Agenda
如果你在寻找一款非常简单的待办应用，非 [Agenda](https://github.com/dahenson/agenda) 莫属。创建任务，标记完成，接着从列表中删除它们。Agenda 会在你删除它们之前一直显示所有任务（完成的或者进行中）。
Agenda 能从 Flathub 应用仓库下载。要安装它，只需[启用 Flathub 作为软件源](https://fedoramagazine.org/install-flathub-apps-fedora/)，接着在软件中心中安装。
### Taskwarrior
[Taskwarrior](https://taskwarrior.org/) 是一个灵活的命令行任务管理程序。它高度可定制化，但同样“开箱即用”。使用简单的命令，你可以创建任务，标记完成，并列出当前进行中的任务。另外，任务可以被标记、添加到项目、搜索和过滤。此外，你可以设置循环任务，并设置任务截止日期。
[之前在 Fedora Magazine 上的文章](/article-9644-1.html) 对 Taskwarrior 的入门做了很好的概述。
在终端中使用这个命令安装 Taskwarrior：
```
sudo dnf install task
```
---
via: <https://fedoramagazine.org/5-tools-to-manage-your-to-do-list-on-fedora/>
作者：[Ryan Lerch](https://fedoramagazine.org/introducing-flatpak/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 PySimpleGUI 轻松为程序和脚本增加 GUI
|
Mike Barnett
|
https://opensource.com/article/18/8/pysimplegui
|
五分钟创建定制 GUI。
|
/data/attachment/album/201809/18/233529t20dq1juyy8hh2ym.jpg.thumb.jpg
|
/data/attachment/album/201809/18/233529t20dq1juyy8hh2ym.jpg
| true | false | true |
lujun9972
|
pinewall
|
wxy
| false |
[
"Python",
"GUI",
"图形界面"
] |
软件开发
|
{
"viewnum": 16473,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
五分钟创建定制 GUI。
| 2018-09-18T23:35:26 | 2018-09-18T23:35:26 | 10,027 |
/article-10027-1.html
|
>
> 五分钟创建定制 GUI。
>
>
>
对于 `.exe` 类型的程序文件，我们可以通过双击鼠标左键打开；但对于 `.py` 类型的 Python 程序，几乎不会有人尝试同样的操作。对于一个（非程序员类型的）典型用户，他们双击打开 `.exe` 文件时预期弹出一个可以交互的窗体。基于 Tkinter，可以通过<ruby> 标准 Python 安装 <rt> standard Python installations </rt></ruby>的方式提供 GUI，但很多程序都不太可能这样做。
如果打开 Python 程序并进入 GUI 界面变得如此容易，以至于真正的初学者也可以掌握，会怎样呢？会有人感兴趣并使用吗？这个问题不好回答，因为直到今天创建自定义 GUI 布局仍不是件容易的事情。
在为程序或脚本增加 GUI 这件事上，似乎存在能力的“错配”。（缺乏这方面能力的）真正的初学者被迫只能使用命令行方式，而很多（具备这方面能力的）高级程序员却不愿意花时间创建一个 Tkinter GUI。
### GUI 框架
Python 的 GUI 框架并不少，其中 Tkinter，wxPython，Qt 和 Kivy 是几种比较主流的框架。此外，还有不少在上述框架基础上封装的简化框架，例如 EasyGUI，PyGUI 和 Pyforms 等。
但问题在于，对于初学者（这里是指编程经验不超过 6 个月的用户）而言，即使是最简单的主流框架，他们也无从下手；他们也可以选择封装过的（简化）框架，但仍难以甚至无法创建自定义 GUI <ruby> 布局 <rt> layout </rt></ruby>。即便学会了某种（简化）框架，也需要编写连篇累牍的代码。
[PySimpleGUI](https://github.com/MikeTheWatchGuy/PySimpleGUI) 尝试解决上述 GUI 难题，它提供了一种简单明了、易于理解、方便自定义的 GUI 接口。如果使用 PySimpleGUI，很多复杂的 GUI 也仅需不到 20 行代码。
### 秘诀
PySimpleGUI 极为适合初学者的秘诀在于，它已经包含了绝大多数原本需要用户编写的代码。PySimpleGUI 会处理按钮<ruby> 回调 <rt> callback </rt></ruby>，无需用户编写代码。对于初学者，在几周内掌握函数的概念已经不容易了，要求其理解回调函数似乎有些强人所难。
在大部分 GUI 框架中，布局 GUI <ruby> 小部件 <rt> widgets </rt></ruby>通常需要写一些代码，每个小部件至少 1-2 行。PySimpleGUI 使用了 “auto-packer” 技术，可以自动创建布局。因而，布局 GUI 窗口不再需要 pack 或 grid 系统。
（LCTT 译注：这里提到的 pack 和 grid 都是 Tkinter 的布局管理器，另外一种叫做 place 。）
最后，PySimpleGUI 框架编写中有效地利用了 Python 语言特性，降低用户代码量并简化 GUI 数据返回的方式。在<ruby> 窗体 <rt> form </rt></ruby>布局中创建小部件时，小部件会被部署到对应的布局中，无需额外的代码。
### GUI 是什么？
绝大多数 GUI 只完成一件事情：收集用户数据并返回。在程序员看来，可以归纳为如下的函数调用：
```
button, values = GUI_Display(gui_layout)
```
绝大多数 GUI 支持的用户行为包括鼠标点击（例如，“确认”，“取消”，“保存”，“是”和“否”等）和内容输入。GUI 本质上可以归结为一行代码。
这也正是 PySimpleGUI （的简单 GUI 模式）的工作原理。当执行命令显示 GUI 后，除非点击鼠标关闭窗体，否则不会执行任何代码。
当然还有更复杂的 GUI，其中鼠标点击后窗口并不关闭；例如，机器人的远程控制界面，聊天窗口等。这类复杂的窗体也可以用 PySimpleGUI 创建。
### 快速创建 GUI
PySimpleGUI 什么时候有用呢？显然，是你需要 GUI 的时候。仅需不超过 5 分钟，就可以让你创建并尝试 GUI。最便捷的 GUI 创建方式就是从 [PySimpleGUI 经典实例](https://pysimplegui.readthedocs.io/en/latest/cookbook/)中拷贝一份代码。具体操作流程如下：
* 找到一个与你需求最接近的 GUI
* 从经典实例中拷贝代码
* 粘贴到 IDE 中并运行
下面我们看一下书中的第一个<ruby> 经典实例 <rt> recipe </rt></ruby>：
```
import PySimpleGUI as sg
# Very basic form. Return values as a list
form = sg.FlexForm('Simple data entry form') # begin with a blank form
layout = [
[sg.Text('Please enter your Name, Address, Phone')],
[sg.Text('Name', size=(15, 1)), sg.InputText('name')],
[sg.Text('Address', size=(15, 1)), sg.InputText('address')],
[sg.Text('Phone', size=(15, 1)), sg.InputText('phone')],
[sg.Submit(), sg.Cancel()]
]
button, values = form.LayoutAndRead(layout)
print(button, values[0], values[1], values[2])
```
运行后会打开一个大小适中的窗体。
如果你只是想收集一些字符串类型的值，拷贝上述经典实例中的代码，稍作修改即可满足你的需求。
你甚至可以只用 5 行代码创建一个自定义 GUI 布局。
```
import PySimpleGUI as sg
form = sg.FlexForm('My first GUI')
layout = [ [sg.Text('Enter your name'), sg.InputText()],
[sg.OK()] ]
button, (name,) = form.LayoutAndRead(layout)
```
### 5 分钟内创建一个自定义 GUI
在简单布局的基础上，通过修改经典实例中的代码，5 分钟内即可使用 PySimpleGUI 创建自定义布局。
在 PySimpleGUI 中，<ruby> 小部件 <rt> widgets </rt></ruby>被称为<ruby> 元素 <rt> elements </rt></ruby>。元素的名称与编码中使用的名称保持一致。
（LCTT 译注：Tkinter 中使用小部件这个词）
#### 核心元素
```
Text
InputText
Multiline
InputCombo
Listbox
Radio
Checkbox
Spin
Output
SimpleButton
RealtimeButton
ReadFormButton
ProgressBar
Image
Slider
Column
```
#### 元素简写
PySimpleGUI 还包含两种元素简写方式。一种是元素类型名称简写，例如 `T` 用作 `Text` 的简写；另一种是元素参数被配置了默认值，你可以无需指定所有参数，例如 `Submit` 按钮默认的文本就是 “Submit”。
```
T = Text
Txt = Text
In = InputText
Input = IntputText
Combo = InputCombo
DropDown = InputCombo
Drop = InputCombo
```
（LCTT 译注：第一种简写就是 Python 类的别名，第二种简写是在返回元素对象的 Python 函数定义时指定了参数的默认值）
#### 按钮简写
一些通用按钮具有简写实现，包括：
```
FolderBrowse
FileBrowse
FileSaveAs
Save
Submit
OK
Ok （LCTT 译注：这里 `k` 是小写）
Cancel
Quit
Exit
Yes
No
```
此外，还有通用按钮功能对应的简写：
```
SimpleButton
ReadFormButton
RealtimeButton
```
（LCTT 译注：其实就是返回 `Button` 类实例的函数）
上面就是 PySimpleGUI 支持的全部元素。如果不在上述列表之中，就不会在你的窗口布局中生效。
（LCTT 译注：上述都是 PySimpleGUI 的类名、类别名或返回实例的函数，自然只能使用列表内的。）
#### GUI 设计模式
对于 GUI 程序，创建并展示窗口的调用大同小异，差异在于元素的布局。
设计模式代码与上面的例子基本一致，只是移除了布局：
```
import PySimpleGUI as sg
form = sg.FlexForm('Simple data entry form')
# Define your form here (it's a list of lists)
button, values = form.LayoutAndRead(layout)
```
（LCTT 译注：这段代码无法运行，只是为了说明每个程序都会用到的设计模式。）
对于绝大多数 GUI，编码流程如下：
* 创建窗体对象
* 以“列表的列表”的形式定义 GUI
* 展示 GUI 并获取元素的值
上述流程与 PySimpleGUI 设计模式部分的代码一一对应。
#### GUI 布局
要创建自定义 GUI，首先要将窗体分割成多个行，因为窗体是一行一行定义的。然后，在每一行中从左到右依次放置元素。
我们得到的就是一个“列表的列表”，类似如下：
```
layout = [ [Text('Row 1')],
[Text('Row 2'), Checkbox('Checkbox 1', OK()), Checkbox('Checkbox 2'), OK()] ]
```
上述布局对应的效果如下：
### 展示 GUI
当你完成布局、拷贝完用于创建和展示窗体的代码后，下一步就是展示窗体并收集用户数据。
下面这行代码用于展示窗体并返回收集的数据：
```
button, values = form.LayoutAndRead(layout)
```
窗体返回的结果由两部分组成：一部分是被点击按钮的名称，另一部分是一个列表，包含所有用户输入窗体的值。
在这个例子中，窗体显示后用户直接点击 “OK” 按钮，返回的结果如下：
```
button == 'OK'
values == [False, False]
```
Checkbox 类型元素返回 `True` 或 `False` 类型的值。由于默认处于未选中状态，两个元素的值都是 `False`。
### 显示元素的值
一旦从 GUI 获取返回值，检查返回变量中的值是个不错的想法。与其使用 `print` 语句进行打印，我们不妨坚持使用 GUI 并在一个窗口中输出这些值。
（LCTT 译注：考虑使用的是 Python 3 版本，`print` 应该是函数而不是语句。）
在 PySimpleGUI 中，有多种消息框可供选取。传递给消息框（函数）的数据会被显示在消息框中；函数可以接受任意数目的参数，你可以轻松的将所有要查看的变量展示出来。
在 PySimpleGUI 中，最常用的消息框是 `MsgBox`。要展示上面例子中的数据，只需编写一行代码：
```
MsgBox('The GUI returned:', button, values)
```
### 整合
好了，你已经了解了基础知识，让我们创建一个包含尽可能多 PySimpleGUI 元素的窗体吧！此外，为了更好的感观效果，我们将采用绿色/棕褐色的配色方案。
```
import PySimpleGUI as sg
sg.ChangeLookAndFeel('GreenTan')
form = sg.FlexForm('Everything bagel', default_element_size=(40, 1))
column1 = [[sg.Text('Column 1', background_color='#d3dfda', justification='center', size=(10,1))],
[sg.Spin(values=('Spin Box 1', '2', '3'), initial_value='Spin Box 1')],
[sg.Spin(values=('Spin Box 1', '2', '3'), initial_value='Spin Box 2')],
[sg.Spin(values=('Spin Box 1', '2', '3'), initial_value='Spin Box 3')]]
layout = [
[sg.Text('All graphic widgets in one form!', size=(30, 1), font=("Helvetica", 25))],
[sg.Text('Here is some text.... and a place to enter text')],
[sg.InputText('This is my text')],
[sg.Checkbox('My first checkbox!'), sg.Checkbox('My second checkbox!', default=True)],
[sg.Radio('My first Radio! ', "RADIO1", default=True), sg.Radio('My second Radio!', "RADIO1")],
[sg.Multiline(default_text='This is the default Text should you decide not to type anything', size=(35, 3)),
sg.Multiline(default_text='A second multi-line', size=(35, 3))],
[sg.InputCombo(('Combobox 1', 'Combobox 2'), size=(20, 3)),
sg.Slider(range=(1, 100), orientation='h', size=(34, 20), default_value=85)],
[sg.Listbox(values=('Listbox 1', 'Listbox 2', 'Listbox 3'), size=(30, 3)),
sg.Slider(range=(1, 100), orientation='v', size=(5, 20), default_value=25),
sg.Slider(range=(1, 100), orientation='v', size=(5, 20), default_value=75),
sg.Slider(range=(1, 100), orientation='v', size=(5, 20), default_value=10),
sg.Column(column1, background_color='#d3dfda')],
[sg.Text('_' * 80)],
[sg.Text('Choose A Folder', size=(35, 1))],
[sg.Text('Your Folder', size=(15, 1), auto_size_text=False, justification='right'),
sg.InputText('Default Folder'), sg.FolderBrowse()],
[sg.Submit(), sg.Cancel()]
]
button, values = form.LayoutAndRead(layout)
sg.MsgBox(button, values)
```
看上面要写不少代码，但如果你试着直接使用 Tkinter 框架实现同样的 GUI，你很快就会发现 PySimpleGUI 版本的代码是多么的简洁。
代码的最后一行打开了一个消息框，效果如下：
消息框函数中的每一个参数的内容都会被打印到单独的行中。本例的消息框中包含两行，其中第二行非常长而且包含列表嵌套。
建议花一点时间将上述结果与 GUI 中的元素一一比对，这样可以更好的理解这些结果是如何产生的。
### 为你的程序或脚本添加 GUI
如果你有一个命令行方式使用的脚本，添加 GUI 不一定意味着完全放弃该脚本。一种简单的方案如下：如果脚本不需要命令行参数，那么可以直接使用 GUI 调用该脚本；反之，就按原来的方式运行脚本。
仅需类似如下的逻辑：
```
if len(sys.argv) == 1:
# collect arguments from GUI
else:
# collect arguements from sys.argv
```
创建并运行 GUI 最便捷的方式就是从 [PySimpleGUI 经典实例](https://pysimplegui.readthedocs.io/en/latest/cookbook/)中拷贝一份代码并修改。
快来试试吧！给你一直疲于手动执行的脚本增加一些趣味。只需 5-10 分钟即可玩转示例脚本。你可能发现一个几乎满足你需求的经典实例；如果找不到，也很容易自己编写一个。即使你真的玩不转，也只是浪费了 5-10 分钟而已。
### 资源
#### 安装方式
支持 Tkinter 的系统就支持 PySimpleGUI，甚至包括<ruby> 树莓派 <rt> Raspberry Pi </rt></ruby>，但你需要使用 Python 3。
```
pip install PySimpleGUI
```
#### 文档
* [手册](https://pysimplegui.readthedocs.io/en/latest/)
* [经典实例](https://pysimplegui.readthedocs.io/en/latest/cookbook/)
* [GitHub repository](https://github.com/MikeTheWatchGuy/PySimpleGUI)
---
via: <https://opensource.com/article/18/8/pysimplegui>
作者：[Mike Barnett](https://opensource.com/users/pysimplegui) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 NetworkManager 随机化你的 MAC 地址
|
Sheogorath, Stuart D Gathman
|
https://fedoramagazine.org/randomize-mac-address-nm/
|
因为固定的 MAC 地址能被轻易地追踪到，所以应该定时进行更换，随机的 MAC 地址是一个好的选择。
|
/data/attachment/album/201809/19/081148cn996dvan14mnl46.png.thumb.jpg
|
/data/attachment/album/201809/19/081148cn996dvan14mnl46.png
| true | false | true |
lujun9972
|
HankChow
|
wxy
| false |
[
"MAC",
"Wi-Fi"
] |
技术
|
{
"viewnum": 10307,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11564,
"displayorder": 0
}
] |
因为固定的 MAC 地址能被轻易地追踪到，所以应该定时进行更换，随机的 MAC 地址是一个好的选择。
| 2018-09-19T08:11:46 | 2018-09-19T08:11:46 | 10,028 |
/article-10028-1.html
|
今时今日，无论在家里的沙发上，还是在外面的咖啡厅，只要打开笔记本电脑，连上 Wi-Fi，就能通过网络与外界保持联系。但现在的 Wi-Fi 热点们大都能够通过[每张网卡对应的唯一 MAC 地址](https://en.wikipedia.org/wiki/MAC_address)来追踪你的设备。下面就来看一下如何避免被追踪。
现在很多人已经开始注重个人隐私这个问题。个人隐私问题并不仅仅指防止他人能够访问到你电脑上的私有内容（这又是另一个问题了），而更多的是指<ruby> 可追踪性 <rt> legibility </rt></ruby>，也就是是否能够被轻易地统计和追踪到。大家都应该[对此更加重视](https://www.ribbonfarm.com/2010/07/26/a-big-little-idea-called-legibility/)。同时，这方面的底线是，服务提供者在得到了用户的授权后才能对用户进行追踪，例如机场的计时 Wi-Fi 只有在用户授权后才能够使用。
因为固定的 MAC 地址能被轻易地追踪到，所以应该定时进行更换，随机的 MAC 地址是一个好的选择。由于 MAC 地址一般只在局域网内使用，因此随机的 MAC 地址也不大会产生[冲突](https://serverfault.com/questions/462178/duplicate-mac-address-on-the-same-lan-possible)。
### 配置 NetworkManager
要将随机的 MAC 地址默认地用于所有的 Wi-Fi 连接，需要创建 `/etc/NetworkManager/conf.d/00-macrandomize.conf` 这个文件：
```
[device]
wifi.scan-rand-mac-address=yes
[connection]
wifi.cloned-mac-address=stable
ethernet.cloned-mac-address=stable
connection.stable-id=${CONNECTION}/${BOOT}
```
然后重启 NetworkManager ：
```
systemctl restart NetworkManager
```
以上配置文件中，将 `cloned-mac-address` 的值设置为 `stable` 就可以在每次 NetworkManager 激活连接的时候都生成相同的 MAC 地址，但连接时使用不同的 MAC 地址。如果要在每次激活连接时也获得随机的 MAC 地址，需要将 `cloned-mac-address` 的值设置为 `random`。
设置为 `stable` 可以从 DHCP 获取相同的 IP 地址，也可以让 Wi-Fi 的<ruby> <a href="https://en.wikipedia.org/wiki/Captive_portal"> 强制主页 </a> <rt> captive portal </rt></ruby>根据 MAC 地址记住你的登录状态。如果设置为 `random` ，在每次连接的时候都需要重新认证（或者点击“我同意”），在使用机场 Wi-Fi 的时候会需要到这种 `random` 模式。可以在这篇 NetworkManager 的[博客文章](https://blogs.gnome.org/thaller/2016/08/26/mac-address-spoofing-in-networkmanager-1-4-0/)中参阅到有关使用 `nmcli` 从终端配置特定连接的详细说明。
使用 `ip link` 命令可以查看当前的 MAC 地址，MAC 地址将会显示在 `ether` 一词的后面。
```
$ ip link
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: enp2s0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc fq_codel state DOWN mode DEFAULT group default qlen 1000
link/ether 52:54:00:5f:d5:4e brd ff:ff:ff:ff:ff:ff
3: wlp1s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DORMANT group default qlen 1000
link/ether 52:54:00:03:23:59 brd ff:ff:ff:ff:ff:ff
```
### 什么时候不能随机化 MAC 地址
当然，在某些情况下确实需要能被追踪到。例如在家用网络中，可能需要将路由器配置为对电脑分配一致的 IP 地址以进行端口转发；再例如公司的雇主可能需要根据 MAC 地址来提供 Wi-Fi 服务，这时候就需要进行追踪。要更改特定的 Wi-Fi 连接，请使用 `nmcli` 查看 NetworkManager 连接并显示当前设置：
```
$ nmcli c | grep wifi
Amtrak_WiFi 5f4b9f75-9e41-47f8-8bac-25dae779cd87 wifi --
StaplesHotspot de57940c-32c2-468b-8f96-0a3b9a9b0a5e wifi --
MyHome e8c79829-1848-4563-8e44-466e14a3223d wifi wlp1s0
...
$ nmcli c show 5f4b9f75-9e41-47f8-8bac-25dae779cd87 | grep cloned
802-11-wireless.cloned-mac-address: --
$ nmcli c show e8c79829-1848-4563-8e44-466e14a3223d | grep cloned
802-11-wireless.cloned-mac-address: stable
```
这个例子在 Amtrak 使用完全随机 MAC 地址（使用默认配置）和 MyHome 的永久 MAC 地址（使用 `stable` 配置）。永久 MAC 地址是在硬件生产的时候分配到网络接口上的，网络管理员能够根据永久 MAC 地址来查看[设备的制造商 ID](https://www.wireshark.org/tools/oui-lookup.html)。
更改配置并重新连接活动的接口：
```
$ nmcli c modify 5f4b9f75-9e41-47f8-8bac-25dae779cd87 802-11-wireless.cloned-mac-address random
$ nmcli c modify e8c79829-1848-4563-8e44-466e14a3223d 802-11-wireless.cloned-mac-address permanent
$ nmcli c down e8c79829-1848-4563-8e44-466e14a3223d
$ nmcli c up e8c79829-1848-4563-8e44-466e14a3223d
$ ip link
...
```
你还可以安装 NetworkManager-tui ，就可以通过可视化界面菜单来编辑连接。
### 总结
当你走在路上时，你要[留意周围的环境](https://www.isba.org/committees/governmentlawyers/newsletter/2013/06/becomingmoreawareafewtipsonkeepingy)，并[警惕可能的危险](http://www.selectinternational.com/safety-blog/aware-of-surroundings-can-reduce-safety-incidents)。同样，在使用公共互联网资源时也要注意你自己的可追踪性。
---
via: <https://fedoramagazine.org/randomize-mac-address-nm/>
作者：[sheogorath](https://fedoramagazine.org/author/sheogorath/),[Stuart D Gathman](https://fedoramagazine.org/author/sdgathman/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Trash-Cli：Linux 上的命令行回收站工具
|
2daygeek
|
https://www.2daygeek.com/trash-cli-command-line-trashcan-linux-system/
|
如果有人在寻找一个命令行回收站工具，那么这儿有一个不错的选择。
|
/data/attachment/album/201809/19/082815fwwwcsw5600z7zkw.jpg.thumb.jpg
|
/data/attachment/album/201809/19/082815fwwwcsw5600z7zkw.jpg
| true | false | true |
ucasFL
|
wxy
| false |
[
"rm",
"回收站",
"删除"
] |
分享
|
{
"viewnum": 21247,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果有人在寻找一个命令行回收站工具，那么这儿有一个不错的选择。
| 2018-09-19T08:28:21 | 2018-09-19T08:28:21 | 10,029 |
/article-10029-1.html
|
相信每个人都对<ruby> 回收站 <rt> trashcan </rt></ruby>很熟悉，因为无论是对 Linux 用户，还是 Windows 用户，或者 Mac 用户来说，它都很常见。当你删除一个文件或目录的时候，该文件或目录会被移动到回收站中。
需要注意的是，当把文件移动到回收站以后，文件系统空间并没有被释放，除非把回收站清空。
如果不想永久删除文件的话（清空回收站），可以利用回收站临时存储被删除了的文件，从而在必要的时候能够帮助我们恢复删除了的文件。
但是，如果在命令行使用 `rm` 命令进行删除操作，那么你是不可能在回收站中找到任何被删除了的文件或目录的。所以，在执行 `rm` 命令前请一定要三思。如果你犯了错误（执行了 `rm` 命令），那么文件就被永久删除了，无法再恢复回来，因为存储在磁盘上的元数据已经不在了。
根据 [freedesktop.org 规范](https://freedesktop.org/wiki/Specifications/trash-spec/)，<ruby> 垃圾 <rt> trash </rt></ruby>是由桌面管理器比如 GNOME、KDE 和 XFCE 等提供的一个特性。当通过文件管理器删除一个文件或目录的时候，该文件或目录将会成为<ruby> 垃圾 <rt> trash </rt></ruby>，然后被移动到回收站中，回收站对应的目录是 `$HOME/.local/share/Trash` 。
回收站目录包含两个子目录：`files` 和 `info` 。`files` 目录存储实际被删除了的文件和目录，`info` 目录包含被删除了的文件和目录的信息，比如文件路径、删除日期和时间，每个文件单独存储。
你可能会问，既然已经有了<ruby> 图形用户界面 <rt> GUI </rt></ruby>的回收站，为什么还需要命令行工具呢？因为对于大多数使用 \*NIX 系统的家伙（包括我）来说，即使使用的是基于图形用户界面的系统，也更喜欢使用命令行而不是图形用户界面。所以，如果有人在寻找一个命令行回收站工具，那么这儿有一个不错的选择。
### Trash-Cli 是什么
[trash-cli](https://github.com/andreafrancia/trash-cli) 是一个命令行回收站工具，并且符合 FreeDesktop.org 的<ruby> 垃圾 <rt> trash </rt></ruby>规范。它能够存储每一个垃圾文件的名字、原始路径、删除日期和权限。
### 如何在 Linux 上安装 Trash-Cli
绝大多数的 Linux 发行版官方仓库都提供了 Trash-Cli 的安装包，所以你可以运行下面这些命令来安装。
对于 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/) 命令来安装 Trash-Cli：
```
$ sudo apt install trash-cli
```
对于 RHEL/CentOS 用户，使用 [yum](https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/) 命令来安装 Trash-Cli：
```
$ sudo yum install trash-cli
```
对于 Fedora 用户，使用 [dnf](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/) 命令来安装 Trash-Cli：
```
$ sudo dnf install trash-cli
```
对于 Arch Linux 用户，使用 [pacman](https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/) 命令来安装 Trash-Cli：
```
$ sudo pacman -S trash-cli
```
对于 openSUSE 用户，使用 [zypper](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/) 命令来安装 Trash-Cli：
```
$ sudo zypper in trash-cli
```
如果你的发行版中没有提供 Trash-Cli 的安装包，那么你也可以使用 `pip` 来安装。为了能够安装 python 包，你的系统中应该会有 `pip` 包管理器。
```
$ sudo pip install trash-cli
Collecting trash-cli
Downloading trash-cli-0.17.1.14.tar.gz
Installing collected packages: trash-cli
Running setup.py bdist_wheel for trash-cli ... done
Successfully installed trash-cli-0.17.1.14
```
### 如何使用 Trash-Cli
Trash-Cli 的使用不难，因为它提供了一个很简单的语法。Trash-Cli 提供了下面这些命令：
* `trash-put`： 删除文件和目录（仅放入回收站中）
* `trash-list` ：列出被删除了的文件和目录
* `trash-restore`：从回收站中恢复文件或目录 trash.
* `trash-rm`：删除回收站中的文件
* `trash-empty`：清空回收站
下面，让我们通过一些例子来试验一下。
1) 删除文件和目录：在这个例子中，我们通过运行下面这个命令，将 `2g.txt` 这一文件和 `magi` 这一文件夹移动到回收站中。
```
$ trash-put 2g.txt magi
```
和你在文件管理器中看到的一样。
2) 列出被删除了的文件和目录：为了查看被删除了的文件和目录，你需要运行下面这个命令。之后，你可以在输出中看到被删除文件和目录的详细信息，比如名字、删除日期和时间，以及文件路径。
```
$ trash-list
2017-10-01 01:40:50 /home/magi/magi/2g.txt
2017-10-01 01:40:50 /home/magi/magi/magi
```
3) 从回收站中恢复文件或目录：任何时候，你都可以通过运行下面这个命令来恢复文件和目录。它将会询问你来选择你想要恢复的文件或目录。在这个例子中，我打算恢复 `2g.txt` 文件，所以我的选择是 `0` 。
```
$ trash-restore
0 2017-10-01 01:40:50 /home/magi/magi/2g.txt
1 2017-10-01 01:40:50 /home/magi/magi/magi
What file to restore [0..1]: 0
```
4) 从回收站中删除文件：如果你想删除回收站中的特定文件，那么可以运行下面这个命令。在这个例子中，我将删除 `magi` 目录。
```
$ trash-rm magi
```
5)清空回收站：如果你想删除回收站中的所有文件和目录，可以运行下面这个命令。
```
$ trash-empty
```
6)删除超过 X 天的垃圾文件：或者，你可以通过运行下面这个命令来删除回收站中超过 X 天的文件。在这个例子中，我将删除回收站中超过 `10` 天的项目。
```
$ trash-empty 10
```
Trash-Cli 可以工作的很好，但是如果你想尝试它的一些替代品，那么你也可以试一试 [gvfs-trash](http://manpages.ubuntu.com/manpages/trusty/man1/gvfs-trash.1.html) 和 [autotrash](https://github.com/bneijt/autotrash) 。
---
via: <https://www.2daygeek.com/trash-cli-command-line-trashcan-linux-system/>
作者：[2daygeek](https://www.2daygeek.com/author/2daygeek/) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Cloud Commander：一个有控制台和编辑器的 Web 文件管理器
|
Sk
|
https://www.ostechnix.com/cloud-commander-a-web-file-manager-with-console-and-editor/
|
Cloud Commander 是一个基于 web 的文件管理程序，它允许你通过任何计算机、移动端或平板电脑的浏览器查看、访问或管理系统文件或文件夹。
|
/data/attachment/album/201809/19/090158z46u3y69ib4o233y.png.thumb.jpg
|
/data/attachment/album/201809/19/090158z46u3y69ib4o233y.png
| true | false | true |
lujun9972
|
fuzheng1998
|
wxy
| false |
[
"文件管理器"
] |
分享
|
{
"viewnum": 8178,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Cloud Commander 是一个基于 web 的文件管理程序，它允许你通过任何计算机、移动端或平板电脑的浏览器查看、访问或管理系统文件或文件夹。
| 2018-09-19T09:01:56 | 2018-09-19T09:01:56 | 10,030 |
/article-10030-1.html
|
**Cloud Commander** 是一个基于 web 的文件管理程序，它允许你通过任何计算机、移动端或平板电脑的浏览器查看、访问或管理系统文件或文件夹。它有两个简单而又经典的面板，并且会像你设备的显示尺寸一样自动转换大小。它也拥有两款内置的叫做 **Dword** 和 **Edward** 的文本编辑器，它们支持语法高亮，并带有一个支持系统命令行的控制台。因此，您可以随时随地编辑文件。Cloud Commander 服务器是一款在 Linux、Windows、Mac OS X 运行的跨平台应用，而且该应用客户端可以在任何一款浏览器上运行。它是用 **JavaScript/Node.Js** 写的，并使用 **MIT** 许可证。
在这个简易教程中，让我们看一看如何在 Ubuntu 18.04 LTS 服务器上安装 Cloud Commander。
### 前提条件
像我之前提到的，是用 Node.js 写的。所以为了安装 Cloud Commander，我们需要首先安装 Node.js。要执行安装，参考下面的指南。
* [如何在 Linux 上安装 Node.js](https://www.ostechnix.com/install-node-js-linux/)
### 安装 Cloud Commander
在安装 Node.js 之后，运行下列命令安装 Cloud Commander:
```
$ npm i cloudcmd -g
```
祝贺！Cloud Commander 已经安装好了。让我们往下继续看看 Cloud Commander 的基本使用。
### 开始使用 Cloud Commander
运行以下命令启动 Cloud Commander：
```
$ cloudcmd
```
**输出示例：**
```
url: http://localhost:8000
```
现在，打开你的浏览器并转到链接：`http://localhost:8000` 或 `http://IP-address:8000`。
从现在开始，您可以直接在本地系统或远程系统或移动设备，平板电脑等Web浏览器中创建，删除，查看，管理文件或文件夹。
如你所见上面的截图，Clouder Commander 有两个面板，十个热键 （`F1` 到 `F10`），还有控制台。
每个热键执行的都是一个任务。
* `F1` – 帮助
* `F2` – 重命名文件/文件夹
* `F3` – 查看文件/文件夹
* `F4` – 编辑文件
* `F5` – 复制文件/文件夹
* `F6` – 移动文件/文件夹
* `F7` – 创建新目录
* `F8` – 删除文件/文件夹
* `F9` – 打开菜单
* `F10` – 打开设置
#### Cloud Commmander 控制台
点击控制台图标。这即将打开系统默认的命令行界面。
在此控制台中，您可以执行各种管理任务，例如安装软件包、删除软件包、更新系统等。您甚至可以关闭或重新引导系统。 因此，Cloud Commander 不仅仅是一个文件管理器，还具有远程管理工具的功能。
#### 创建文件/文件夹
要创建新的文件或文件夹就右键单击任意空位置并找到 “New - >File or Directory”。
#### 查看文件
你可以查看图片，查看音视频文件。
#### 上传文件
另一个很酷的特性是我们可以从任何系统或设备简单地上传一个文件到 Cloud Commander 系统。
要上传文件，右键单击 Cloud Commander 面板的任意空白处，并且单击“Upload”选项。
选择你想要上传的文件。
另外，你也可以上传来自像 Google 云盘、Dropbox、Amazon 云盘、Facebook、Twitter、Gmail、GitHub、Picasa、Instagram 还有很多的云服务上的文件。
要从云端上传文件, 右键单击面板的任意空白处，并且右键单击面板任意空白处并选择“Upload from Cloud”。
选择任意一个你选择的网络服务，例如谷歌云盘。点击“Connect to Google drive”按钮。
下一步，用 Cloud Commander 验证你的谷歌云端硬盘，从谷歌云端硬盘选择文件并点击“Upload”。
#### 更新 Cloud Commander
要更新到最新的可用版本，执行下面的命令：
```
$ npm update cloudcmd -g
```
#### 总结
据我测试，它运行很好。在我的 Ubuntu 服务器测试期间，我没有遇到任何问题。此外，Cloud Commander 不仅是基于 Web 的文件管理器，还可以充当执行大多数 Linux 管理任务的远程管理工具。 您可以创建文件/文件夹、重命名、删除、编辑和查看它们。此外，您可以像在终端中在本地系统中那样安装、更新、升级和删除任何软件包。当然，您甚至可以从 Cloud Commander 控制台本身关闭或重启系统。 还有什么需要的吗？ 尝试一下，你会发现它很有用。
目前为止就这样吧。 我将很快在这里发表另一篇有趣的文章。 在此之前，请继续关注我们。
祝贺！
---
via: <https://www.ostechnix.com/cloud-commander-a-web-file-manager-with-console-and-editor/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[fuzheng1998](https://github.com/fuzheng1998) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何使用 Apache 构建 URL 缩短服务
|
Ben Cotton
|
https://opensource.com/article/18/7/apache-url-shortener
|
用 Apache HTTP 服务器的 mod_rewrite 功能创建你自己的短链接。
|
/data/attachment/album/201809/19/223103exq5ziz5baxbuix1.png.thumb.jpg
|
/data/attachment/album/201809/19/223103exq5ziz5baxbuix1.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"短链接",
"Apache"
] |
技术
|
{
"viewnum": 5928,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用 Apache HTTP 服务器的 mod_rewrite 功能创建你自己的短链接。
| 2018-09-19T22:30:27 | 2018-09-19T22:30:27 | 10,031 |
/article-10031-1.html
|
>
> 用 Apache HTTP 服务器的 mod\_rewrite 功能创建你自己的短链接。
>
>
>
很久以前，人们开始在 Twitter 上分享链接。140 个字符的限制意味着 URL 可能消耗一条推文的大部分（或全部），因此人们使用 URL 缩短服务。最终，Twitter 加入了一个内置的 URL 缩短服务（[t.co](http://t.co)）。
字符数现在不重要了，但还有其他原因要缩短链接。首先，缩短服务可以提供分析功能 —— 你可以看到你分享的链接的受欢迎程度。它还简化了制作易于记忆的 URL。例如，[bit.ly/INtravel](http://bit.ly/INtravel) 比<https://www.in.gov/ai/appfiles/dhs-countyMap/dhsCountyMap.html>更容易记住。如果你想预先共享一个链接，但还不知道最终地址，这时 URL 缩短服务可以派上用场。。
与任何技术一样，URL 缩短服务并非都是正面的。通过屏蔽最终地址，缩短的链接可用于指向恶意或冒犯性内容。但是，如果你仔细上网，URL 缩短服务是一个有用的工具。
我们之前在网站上[发布过缩短服务的文章](https://opensource.com/article/17/3/url-link-shortener)，但也许你想要运行一些由简单的文本文件支持的缩短服务。在本文中，我们将展示如何使用 Apache HTTP 服务器的 mod\_rewrite 功能来设置自己的 URL 缩短服务。如果你不熟悉 Apache HTTP 服务器，请查看 David Both 关于[安装和配置](https://opensource.com/article/18/2/how-configure-apache-web-server)它的文章。
### 创建一个 VirtualHost
在本教程中，我假设你购买了一个很酷的域名，你将它专门用于 URL 缩短服务。例如，我的网站是 [funnelfiasco.com](http://funnelfiasco.com)，所以我买了 [funnelfias.co](http://funnelfias.co) 用于我的 URL 缩短服务（好吧，它不是很短，但它可以满足我的虚荣心）。如果你不将缩短服务作为单独的域运行，请跳到下一部分。
第一步是设置将用于 URL 缩短服务的 VirtualHost。有关 VirtualHost 的更多信息，请参阅 [David Both 的文章](https://opensource.com/article/18/3/configuring-multiple-web-sites-apache)。这步只需要几行：
```
<VirtualHost *:80>
ServerName funnelfias.co
</VirtualHost>
```
### 创建重写规则
此服务使用 HTTPD 的重写引擎来重写 URL。如果你在上面的部分中创建了 VirtualHost，则下面的配置跳到你的 VirtualHost 部分。否则跳到服务器的 VirtualHost 或主 HTTPD 配置。
```
RewriteEngine on
RewriteMap shortlinks txt:/data/web/shortlink/links.txt
RewriteRule ^/(.+)$ ${shortlinks:$1} [R=temp,L]
```
第一行只是启用重写引擎。第二行在文本文件构建短链接的映射。上面的路径只是一个例子。你需要使用系统上使用有效路径（确保它可由运行 HTTPD 的用户帐户读取）。最后一行重写 URL。在此例中，它接受任何字符并在重写映射中查找它们。你可能希望重写时使用特定的字符串。例如，如果你希望所有缩短的链接都是 “slX”（其中 X 是数字），则将上面的 `(.+)` 替换为 `(sl\d+)`。
我在这里使用了临时重定向（HTTP 302）。这能让我稍后更新目标 URL。如果希望短链接始终指向同一目标，则可以使用永久重定向（HTTP 301）。用 `permanent` 替换第三行的 `temp`。
### 构建你的映射
编辑配置文件 `RewriteMap` 行中的指定文件。格式是空格分隔的键值存储。在每一行上放一个链接：
```
osdc https://opensource.com/users/bcotton
twitter https://twitter.com/funnelfiasco
swody1 https://www.spc.noaa.gov/products/outlook/day1otlk.html
```
### 重启 HTTPD
最后一步是重启 HTTPD 进程。这是通过 `systemctl restart httpd` 或类似命令完成的（命令和守护进程名称可能因发行版而不同）。你的链接缩短服务现已启动并运行。当你准备编辑映射时，无需重新启动 Web 服务器。你所要做的就是保存文件，Web 服务器将获取到差异。
### 未来的工作
此示例为你提供了基本的 URL 缩短服务。如果你想将开发自己的管理接口作为学习项目，它可以作为一个很好的起点。或者你可以使用它分享容易记住的链接到那些容易忘记的 URL。
---
via: <https://opensource.com/article/18/7/apache-url-shortener>
作者：[Ben Cotton](https://opensource.com/users/bcotton) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我从编程面试中学到的
|
Edaena Salinas
|
https://medium.freecodecamp.org/what-i-learned-from-programming-interviews-29ba49c9b851
|
聊聊白板编程面试
|
/data/attachment/album/201809/19/232639udzlfvfqy6v66fvt.jpeg.thumb.jpg
|
/data/attachment/album/201809/19/232639udzlfvfqy6v66fvt.jpeg
| true | false | true |
DavidChenLiang
|
wxy
| false |
[
"面试"
] |
观点
|
{
"viewnum": 4620,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
聊聊白板编程面试
| 2018-09-19T23:25:00 | 2018-09-19T23:25:00 | 10,032 |
/article-10032-1.html
|
在 2017 年，我参加了 ‘计算机行业中的女性’ 的[Grace Hopper 庆祝活动](https://anitab.org/event/2017-grace-hopper-celebration-women-computing/)。这个活动是这类科技活动中最大的一个。共有 17,000 名女性IT工作者参加。
这个会议有个大型的配套招聘会，会上有招聘公司来面试会议参加者。有些人甚至现场拿到 offer。我在现场晃荡了一下，注意到一些应聘者看上去非常紧张忧虑。我还隐隐听到应聘者之间的谈话，其中一些人谈到在面试中做的并不好。
我走近我听到谈话的那群人并和她们聊了起来并给了一些面试上的小建议。我想我的建议还是比较偏基本的，如“（在面试时）一开始给出个能工作的解决方案也还说的过去”之类的，但是当她们听到我的一些其他的建议时还是颇为吃惊。
为了能更多的帮到像她们一样的小白面试者，我收集了一些过去对我有用的小点子，这些小点子我已经发表在了 [prodcast episode](https://thewomenintechshow.com/2017/12/18/programming-interviews/) 上。它们也是这篇文章的主题。
为了实习生职位和全职工作，我做过很多次的面试。当我还在大学主修计算机科学时，学校每个秋季学期都有招聘会，第一轮招聘会在校园里举行。(我在第一和最后一轮都搞砸过。)不过，每次面试后，我都会反思哪些方面我能做的更好，我还会和朋友们做模拟面试，这样我就能从他们那儿得到更多的面试反馈。
不管我们怎么样找工作: 工作中介、网络，或者学校招聘，他们的招聘流程中都会涉及到技术面试：
近年来，我注意到了一些新的不同的面试形式出现了：
* 与招聘方的一位工程师结对编程
* 网络在线测试及在线编码
* 白板编程（LCTT 译注： 这种形式应该不新了）
我将重点谈谈白板面试，这种形式我经历的最多。我有过很多次面试，有些挺不错的，有些被我搞砸了。
#### 我做错的地方
首先，我想回顾一下我做的不好的地方。知错能改，善莫大焉。
当面试者提出一个要我解决的问题时， 我立即马上立刻开始在白板上写代码，什么都不问。
这里我犯了两个错误：
#### 没有澄清对解决问题有关键作用的信息
比如，我们是否只用处理数字或者字符串？我们要支持多种数据类型吗？如果你在开始解题前不去问这些问题的话，你的面试官会有一种不好的印象：这个人在我们公司的话，他不会在开始项目工作之前不问清楚到底要做什么。而这恰恰是在工作场合很重要的一个工作习惯。公司可不像学校，你在开始工作前可不会得到写有所有详细步骤的作业说明。你得靠自己找到这些步骤并自己定义他们。
#### 只会默默思考，不去记录想法或和面试官沟通
在面试中，很多时候我也会傻傻站在那思考，什么都不写。我和一个朋友模拟面试的时候，他告诉我因为他曾经和我一起工作过所以他知道我在思考，但是如果他是个陌生的面试官的话，他会觉得我正站在那冥思苦想，毫无头绪。不要急匆匆的直奔解题而去是很重要的。花点时间多想想各种解题的可能性。有时候面试官会乐意和你一起探索解题的步骤。不管怎样，这就是在一家公司开工作会议的的普遍方式，大家各抒己见，一起讨论如何解决问题。
### 想到一个解题方法
在你开始写代码之前，如果你能总结一下要使用到的算法就太棒了。不要上来就写代码并认为你的代码肯定能解决问题。
这是对我管用的步骤：
1. 头脑风暴
2. 写代码
3. 处理错误路径
4. 测试
#### 1、 头脑风暴
对我来说，我会首先通过一些例子来视觉化我要解决的问题。比如说如果这个问题和数据结构中的树有关，我就会从树底层的空节点开始思考，如何处理一个节点的情况呢？两个节点呢？三个节点呢？这能帮助你从具体例子里抽象出你的解决方案。
在白板上先写下你的算法要做的事情列表。这样做，你往往能在开始写代码前就发现 bug 和缺陷（不过你可得掌握好时间）。我犯过的一个错误是我花了过多的时间在澄清问题和头脑风暴上，最后几乎没有留下时间给我写代码。你的面试官可能没有机会看你在白板上写下代码，这可太糟了。你可以带块手表，或者房间有钟的话，你也可以抬头看看时间。有些时候面试者会提醒你你已经得到了所有的信息（这时你就不要再问别的了），“我想我们已经把所有需要的信息都澄清了，让我们写代码实现吧”。
#### 2、 开始写代码，一气呵成
如果你还没有得到问题的完美解决方法，从最原始的解法开始总是可以的。当你在向面试官解释最显而易见的解法时，你要想想怎么去完善它，并指明这种做法是最原始的，未加优化的。（请熟悉算法中的 `O()` 的概念，这对面试非常有用。）在向面试者提交前请仔细检查你的解决方案两三遍。面试者有时会给你些提示， “还有更好的方法吗？”，这句话的意思是面试官提示你有更优化的解决方案。
#### 3、 错误处理
当你在编码时，对你想做错误处理的代码行做个注释。当面试者说，“很好，这里你想到了错误处理。你想怎么处理呢？抛出异常还是返回错误码？”，这将给你个机会去引出关于代码质量的一番讨论。当然，这种地方提出几个就够了。有时，面试者为了节省编码的时间，会告诉你可以假设外界输入的参数都已经通过了校验。不管怎样，你都要展现你对错误处理和编码质量的重要性的认识。
#### 4、 测试
在编码完成后，用你在前面头脑风暴中写的用例来在你脑子里“跑”一下你的代码，确定万无一失。例如你可以说，“让我用前面写下的树的例子来跑一下我的代码，如果是一个节点是什么结果，如果是两个节点是什么结果……”
在你结束之后，面试者有时会问你你将会怎么测试你的代码，你会涉及什么样的测试用例。我建议你用下面不同的分类来组织你的错误用例：
一些分类可以为：
1. 性能
2. 错误用例
3. 期望的正常用例
对于性能测试，要考虑极端数量下的情况。例如，如果问题是关于列表的，你可以说你将会使用一个非常大的列表以及的非常小的列表来测试。如果和数字有关，你将会测试系统中的最大整数和最小整数。我建议读一些有关软件测试的书来得到更多的知识。在这个领域我最喜欢的书是 《[我们在微软如何测试软件](https://www.amazon.com/How-We-Test-Software-Microsoft/dp/0735624259)》。
对于错误用例，想一下什么是期望的错误情况并一一写下。
对于正向期望用例，想想用户需求是什么？你的解决方案要解决什么问题？这些都可以成为正向期望用例。
### “你还有什么要问我的吗？”
面试最后总是会留几分钟给你问问题。我建议你在面试前写下你想问的问题。千万别说，“我没什么问题了”，就算你觉得面试砸了或者你对这间公司不怎么感兴趣，你总有些东西可以问问。你甚至可以问面试者他最喜欢自己的工作什么，最讨厌自己的工作什么。或者你可以问问面试官的工作具体是什么，在用什么技术和实践。不要因为觉得自己在面试中做的不好而心灰意冷，不想问什么问题。
### 申请一份工作
关于找工作和申请工作，有人曾经告诉我，你应该去找你真正有激情工作的地方。去找一家你喜欢的公司，或者你喜欢使用的产品，看看你能不能去那儿工作。
我个人并不推荐你用上述的方法去找工作。你会排除很多很好的公司，特别是你是在找实习工作或者入门级的职位时。
你也可以集中在其他的一些目标上。如：我想从这个工作里得到哪方面的更多经验？这个工作是关于云计算？Web 开发？或是人工智能？当在招聘会上与招聘公司沟通时，看看他们的工作单位有没有在这些领域的。你可能会在一家并非在你的想去公司列表上的公司（或非盈利机构）里找到你想找的职位。
#### 换组
在这家公司里的第一个组里呆了一年半以后，我觉得是时候去探索一下不同的东西了。我找到了一个我喜欢的组并进行了 4 轮面试。结果我搞砸了。
我什么都没有准备，甚至都没在白板上练练手。我当时的逻辑是，如果我都已经在一家公司干了快 2 年了，我还需要练什么？我完全错了，我在接下去的白板面试中跌跌撞撞。我的板书写得太小，而且因为没有从最左上角开始写代码，我的代码大大超出了一个白板的空间，这些都导致了白板面试失败。
我在面试前也没有刷过数据结构和算法题。如果我做了的话，我将会在面试中更有信心。就算你已经在一家公司担任了软件工程师，在你去另外一个组面试前，我强烈建议你在一块白板上演练一下如何写代码。
对于换项目组这件事，如果你是在公司内部换组的话，事先能同那个组的人非正式聊聊会很有帮助。对于这一点，我发现几乎每个人都很乐于和你一起吃个午饭。人一般都会在中午有空，约不到人或者别人正好有会议冲突的风险会很低。这是一种非正式的途径来了解你想去的组正在干什么，以及这个组成员个性是怎么样的。相信我，你能从一次午餐中得到很多信息，这可会对你的正式面试帮助不小。
非常重要的一点是，你在面试一个特定的组时，就算你在面试中做的很好，因为文化不契合的原因，你也很可能拿不到 offer。这也是为什么我一开始就想去见见组里不同的人的原因（有时这也不太可能），我希望你不要被一次拒绝所击倒，请保持开放的心态，选择新的机会，并多多练习。
以上内容选自 《[The Women in Tech Show: Technical Interviews with Prominent Women in Tech](https://thewomenintechshow.com/)》的 “[编程面试](https://thewomenintechshow.com/2017/12/18/programming-interviews/)”章节，
---
作者简介：
微软研究院 Software Engineer II， [www.thewomenintechshow.com](http://www.thewomenintechshow.com) 站长，所有观点都只代表本人意见。
---
via: <https://medium.freecodecamp.org/what-i-learned-from-programming-interviews-29ba49c9b851>
作者：[Edaena Salinas](https://medium.freecodecamp.org/@edaenas) 译者：[DavidChenLiang](https://github.com/DavidChenLiang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
初学者指南：ZFS 是什么，为什么要使用 ZFS？
|
John Paul
|
https://itsfoss.com/what-is-zfs/
|
今天，我们来谈论一下 ZFS，一个先进的文件系统。我们将讨论 ZFS 从何而来，它是什么，以及为什么它在科技界和企业界如此受欢迎。
|
/data/attachment/album/201809/20/231709ns0cc5l3pii2i3ph.png.thumb.jpg
|
/data/attachment/album/201809/20/231709ns0cc5l3pii2i3ph.png
| true | false | true |
lujun9972
|
ucasFL
|
wxy
| false |
[
"文件系统",
"ZFS"
] |
技术
|
{
"viewnum": 20860,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.123.120.26",
"message": "原来如此 解惑了",
"username": "TopStop [Chrome 73.0|Windows 10]",
"date": "2019-04-03T14:16:27"
},
{
"postip": "112.64.196.54",
"message": "0ddddddddddddddddddddddddddd",
"username": "来自上海的 Chrome 110.0|Mac 10.15 用户",
"date": "2023-12-11T17:54:38"
}
] |
[] |
今天，我们来谈论一下 ZFS，一个先进的文件系统。我们将讨论 ZFS 从何而来，它是什么，以及为什么它在科技界和企业界如此受欢迎。
| 2018-09-20T23:17:00 | 2018-09-20T23:17:00 | 10,034 |
/article-10034-1.html
|
今天，我们来谈论一下 ZFS，一个先进的文件系统。我们将讨论 ZFS 从何而来，它是什么，以及为什么它在科技界和企业界如此受欢迎。
虽然我是一个美国人，但我更喜欢读成 ZedFS 而不是 ZeeFS，因为前者听起来更酷一些。你可以根据你的个人喜好来发音。
>
> 注意：在这篇文章中，你将会看到 ZFS 被提到很多次。当我在谈论特性和安装的时候，我所指的是 OpenZFS 。自从<ruby> 甲骨文 <rt> Oracle </rt></ruby>公司放弃 OpenSolaris 项目之后，ZFS（由甲骨文公司开发）和 OpenZFS 已经走向了不同的发展道路。
>
>
>
### ZFS 的历史
<ruby> Z 文件系统 <rt> Z File System </rt></ruby>（ZFS）是由 [Matthew Ahrens 和 Jeff Bonwick](https://wiki.gentoo.org/wiki/ZFS) 在 2001 年开发的。ZFS 是作为[<ruby> 太阳微系统 <rt> Sun MicroSystem </rt></ruby>](http://en.wikipedia.org/wiki/Sun_Microsystems) 公司的 [OpenSolaris](http://en.wikipedia.org/wiki/Opensolaris) 的下一代文件系统而设计的。在 2008 年，ZFS 被移植到了 FreeBSD 。同一年，一个移植 [ZFS 到 Linux](https://zfsonlinux.org/) 的项目也启动了。然而，由于 ZFS 是<ruby> <a href="https://en.wikipedia.org/wiki/Common_Development_and_Distribution_License"> 通用开发和发布许可证 </a> <rt> Common Development and Distribution License </rt></ruby>（CDDL）许可的，它和 [GNU 通用公共许可证](https://en.wikipedia.org/wiki/GNU_General_Public_License) 不兼容，因此不能将它迁移到 Linux 内核中。为了解决这个问题，绝大多数 Linux 发行版提供了一些方法来安装 ZFS 。
在甲骨文公司收购太阳微系统公司之后不久，OpenSolaris 就闭源了，这使得 ZFS 的之后的开发也变成闭源的了。许多 ZFS 开发者对这件事情非常不满。[三分之二的 ZFS 核心开发者](https://wiki.gentoo.org/wiki/ZFS)，包括 Ahrens 和 Bonwick，因为这个决定而离开了甲骨文公司。他们加入了其它公司，并于 2013 年 9 月创立了 [OpenZFS](http://www.open-zfs.org/wiki/Main_Page) 这一项目。该项目引领着 ZFS 的开源开发。
让我们回到上面提到的许可证问题上。既然 OpenZFS 项目已经和 Oracle 公司分离开了，有人可能好奇他们为什么不使用和 GPL 兼容的许可证，这样就可以把它加入到 Linux 内核中了。根据 [OpenZFS 官网](http://www.open-zfs.org/wiki/FAQ#Do_you_plan_to_release_OpenZFS_under_a_license_other_than_the_CDDL.3F) 的介绍，更改许可证需要联系所有为当前 OpenZFS 实现贡献过代码的人（包括初始的公共 ZFS 代码以及 OpenSolaris 代码），并得到他们的许可才行。这几乎是不可能的（因为一些贡献者可能已经去世了或者很难找到），因此他们决定保留原来的许可证。
### ZFS 是什么，它有什么特性？
正如前面所说过的，ZFS 是一个先进的文件系统。因此，它有一些有趣的[特性](https://wiki.archlinux.org/index.php/ZFS)。比如：
* 存储池
* 写时拷贝
* 快照
* 数据完整性验证和自动修复
* RAID-Z
* 最大单个文件大小为 16 EB（1 EB = 1024 PB）
* 最大 256 千万亿（256\*10<sup> 15</sup> ）的 ZB（1 ZB = 1024 EB）的存储
让我们来深入了解一下其中一些特性。
#### 存储池
与大多数文件系统不同，ZFS 结合了文件系统和卷管理器的特性。这意味着，它与其他文件系统不同，ZFS 可以创建跨越一系列硬盘或池的文件系统。不仅如此，你还可以通过添加硬盘来增大池的存储容量。ZFS 可以进行[分区和格式化](https://www.howtogeek.com/175159/an-introduction-to-the-z-file-system-zfs-for-linux/)。
*ZFS 存储池*
#### 写时拷贝
<ruby> <a href="https://www.freebsd.org/doc/handbook/zfs-term.html"> 写时拷贝 </a> <rt> Copy-on-write </rt></ruby>是另一个有趣并且很酷的特性。在大多数文件系统上，当数据被重写时，它将永久丢失。而在 ZFS 中，新数据会写到不同的块。写完成之后，更新文件系统元数据信息，使之指向新的数据块（LCTT 译注：更新之后，原数据块成为磁盘上的垃圾，需要有对应的垃圾回收机制）。这确保了如果在写新数据的时候系统崩溃（或者发生其它事，比如突然断电），那么原数据将会保存下来。这也意味着，在系统发生崩溃之后，不需要运行 [fsck](https://en.wikipedia.org/wiki/Fsck) 来检查和修复文件系统。
#### 快照
写时拷贝使得 ZFS 有了另一个特性：<ruby> 快照 <rt> snapshots </rt></ruby>。ZFS 使用快照来跟踪文件系统中的更改。[快照](https://www.freebsd.org/doc/handbook/zfs-term.html)包含文件系统的原始版本（文件系统的一个只读版本），实时文件系统则包含了自从快照创建之后的任何更改。没有使用额外的空间。因为新数据将会写到实时文件系统新分配的块上。如果一个文件被删除了，那么它在快照中的索引也会被删除。所以，快照主要是用来跟踪文件的更改，而不是文件的增加和创建。
快照可以挂载成只读的，以用来恢复一个文件的过去版本。实时文件系统也可以回滚到之前的快照。回滚之后，自从快照创建之后的所有更改将会丢失。
#### 数据完整性验证和自动修复
当向 ZFS 写入新数据时，会创建该数据的校验和。在读取数据的时候，使用校验和进行验证。如果前后校验和不匹配，那么就说明检测到了错误，然后，ZFS 会尝试自动修正错误。
#### RAID-Z
ZFS 不需要任何额外软件或硬件就可以处理 RAID（磁盘阵列）。毫不奇怪，因为 ZFS 有自己的 RAID 实现：RAID-Z 。RAID-Z 是 RAID-5 的一个变种，不过它克服了 RAID-5 的写漏洞：意外重启之后，数据和校验信息会变得不同步（LCTT 译注：RAID-5 的条带在正写入数据时，如果这时候电源中断，那么奇偶校验数据将跟该部分数据不同步，因此前边的写无效；RAID-Z 用了 “可变宽的 RAID 条带” 技术，因此所有的写都是全条带写入）。为了使用[基本级别的 RAID-Z](https://wiki.archlinux.org/index.php/ZFS/Virtual_disks#Creating_and_Destroying_Zpools)（RAID-Z1），你需要至少三块磁盘，其中两块用来存储数据，另外一块用来存储[奇偶校验信息](https://www.pcmag.com/encyclopedia/term/60364/raid-parity)。而 RAID-Z2 需要至少两块磁盘存储数据以及两块磁盘存储校验信息。RAID-Z3 需要至少两块磁盘存储数据以及三块磁盘存储校验信息。另外，只能向 RAID-Z 池中加入偶数倍的磁盘，而不能是奇数倍的。
#### 巨大的存储潜力
创建 ZFS 的时候，它是作为[最后一个文件系统](https://web.archive.org/web/20060428092023/http://www.sun.com/2004-0914/feature/)而设计的 。那时候，大多数文件系统都是 64 位的，ZFS 的创建者决定直接跳到 128 位，等到将来再来证明这是对的。这意味着 ZFS 的容量大小是 32 位或 64 位文件系统的 1600 亿亿倍。事实上，Jeff Bonwick（其中一个创建者）说：“完全填满一个 128 位的存储池所需要的[能量](https://blogs.oracle.com/bonwick/128-bit-storage:-are-you-high)，从字面上讲，比煮沸海洋需要的还多。”
### 如何安装 ZFS？
如果你想立刻使用 ZFS（开箱即用），那么你需要安装 [FreeBSD](https://www.freebsd.org/) 或一个[使用 illumos 内核的操作系统](https://wiki.illumos.org/display/illumos/Distributions)。[illumos](https://wiki.illumos.org/display/illumos/illumos+Home) 是 OpenSolaris 内核的一个克隆版本。
事实上，支持 [ZFS 是一些有经验的 Linux 用户选择 BSD 的主要原因](https://itsfoss.com/why-use-bsd/)。
如果你想在 Linux 上尝试 ZFS，那么只能在存储文件系统上使用。据我所知，没有任何 Linux 发行版可以在根目录上安装 ZFS，实现开箱即用。如果你对在 Linux 上尝试 ZFS 感兴趣，那么 [ZFS on Linux 项目](https://zfsonlinux.org/) 上有大量的教程可以指导你怎么做。
### 附加说明
这篇文章论述了 ZFS 的优点。现在，让我来告诉你一个关于 ZFS 很现实的问题。使用 RAID-Z [会很贵](http://louwrentius.com/the-hidden-cost-of-using-zfs-for-your-home-nas.html)，因为你需要购买大量的磁盘来增大存储空间。
你已经使用过 ZFS 了吗？你的使用经验是什么样的？请在下面的评论中告诉我们。
如果你觉得这篇文章有趣，请花一分钟的时间把它分享到社交媒体、极客新闻或 [Reddit](http://reddit.com/r/linuxusersgroup) 。
---
via: <https://itsfoss.com/what-is-zfs/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Flash Player 的两种开源替代方案
|
Opensource.com
|
https://opensource.com/alternatives/flash-media-player
|
Adobe 将于 2020 年终止对 Flash 媒体播放器的支持，但仍有很多人们希望访问的 Flash 视频。这里有两个开源的替代品或许可以帮到你。
|
/data/attachment/album/201809/21/161024gdcpdc7v70v7w37i.png.thumb.jpg
|
/data/attachment/album/201809/21/161024gdcpdc7v70v7w37i.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Flash"
] |
分享
|
{
"viewnum": 16798,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Adobe 将于 2020 年终止对 Flash 媒体播放器的支持，但仍有很多人们希望访问的 Flash 视频。这里有两个开源的替代品或许可以帮到你。
| 2018-09-21T16:10:18 | 2018-09-21T16:10:18 | 10,035 |
/article-10035-1.html
|
>
> Adobe 将于 2020 年终止对 Flash 媒体播放器的支持，但仍有很多人们希望访问的 Flash 视频。这里有两个开源的替代品或许可以帮到你。
>
>
>
2017 年 7 月，Adobe 为 Flash Media Player 敲响了[丧钟](https://theblog.adobe.com/adobe-flash-update/)，宣布将在 2020 年终止对曾经无处不在的在线视频播放器的支持。但事实上，在一系列损害了其声誉的零日攻击后，Flash 的份额在过去的 8 年一直在下跌。苹果公司在 2010 年宣布它不会支持这项技术后，其未来趋于黯淡，并且在谷歌停止在 Chrome 浏览器中默认启用 Flash（支持 HTML5）后，它的消亡在 2016 年进一步加速。
即便如此，Adobe 仍然每月发布该软件的更新，截至 2018 年 8 月，它在网站的使用率从 2011 年的 28.5% 下降到[仅 4.4％](https://w3techs.com/technologies/details/cp-flash/all/all)。还有更多证据表明 Flash 的下滑：谷歌工程总监 [Parisa Tabriz 说](https://www.bleepingcomputer.com/news/security/google-chrome-flash-usage-declines-from-80-percent-in-2014-to-under-8-percent-today/)通过浏览器访问 Flash 内容的 Chrome 用户数量从 2014 年的 80％ 下降到 2018 年的 8％。
尽管如今很少有视频创作者以 Flash 格式发布，但仍有很多人们希望在未来几年内访问的 Flash 视频。鉴于官方支持的日期已经屈指可数，开源软件创建者有很好的机会涉足 Adobe Flash 媒体播放器的替代品。这其中两个应用是 Lightspark 和 GNU Gnash。它们都不是完美的替代品，但来自贡献者的帮助可以使它们成为可行的替代品。
### Lightspark
[Lightspark](http://lightspark.github.io/) 是 Linux 上的 Flash Player 替代品。虽然它仍处于 alpha 状态，但自从 Adobe 在 2017 宣布废弃 Adobe 以来，开发速度已经加快。据其网站称，Lightspark 实现了 60% 的 Flash API，可在许多流行网站包括 BBC 新闻、Google Play 音乐和亚马逊音乐上[使用](https://github.com/lightspark/lightspark/wiki/Site-Support)。
Lightspark 是用 C++/C 编写的，并在 [LGPLv3](https://github.com/lightspark/lightspark/blob/master/COPYING) 下许可。该项目列出了 41 个贡献者，并正在积极征求错误报告和其他贡献。有关更多信息，请查看其 [GitHub 仓库](https://github.com/lightspark/lightspark/wiki/Site-Support)。
### GNU Gnash
[GNU Gnash](https://www.gnu.org/software/gnash/) 是一个用于 GNU/Linux 操作系统，包括 Ubuntu、Fedora 和 Debian 的 Flash Player。它作为独立软件和插件可用于 Firefox 和 Konqueror 浏览器中。
Gnash 的主要缺点是它不支持最新版本的 Flash 文件 —— 它支持大多数 Flash SWF v7 功能，一些 v8 和 v9 功能，不支持 v10 文件。它处于测试阶段，由于它在 [GNU GPLv3 或更高版本](http://www.gnu.org/licenses/gpl-3.0.html)下许可，因此你可以帮助实现它的现代化。访问其[项目页面](http://savannah.gnu.org/projects/gnash/)获取更多信息。
### 想要创建 Flash 吗？
仅因为大多数人都不会发布 Flash 视频，但这并不意味着永远不需要创建 SWF 文件。如果你发现自己需要，这两个开源工具可能会有所帮助：
* [Motion-Twin ActionScript 2 编译器](http://tech.motion-twin.com/mtasc.html)（MTASC）：一个命令行编译器，它可以在没有 Adobe Animate（Adobe 当前的视频创建软件）的情况下生成 SWF 文件。
* [Ming](http://www.libming.org/)：用 C 编写的可以生成 SWF 文件的库。它还包含一些可用于处理 Flash 的[程序](http://www.libming.org/WhatsIncluded)。
---
via: <https://opensource.com/alternatives/flash-media-player>
作者：[Opensource.com](https://opensource.com) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
区块链简史
|
Vegard Nordahl & Meghana Rao
|
https://www.myblockchainblog.com/blog/a-brief-history-of-blockchain
|
很久以前，在一个遥远的星系……一份题为“比特币：点对点电子现金系统”的神秘白皮书以笔名中本聪发布。
|
/data/attachment/album/201809/21/164229su2wcgcf88s22g21.jpg.thumb.jpg
|
/data/attachment/album/201809/21/164229su2wcgcf88s22g21.jpg
| true | false | true |
jasminepeng
|
jasminepeng
|
wxy
| false |
[
"区块链"
] |
区块链
|
{
"viewnum": 5343,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10004,
"displayorder": 0
}
] |
很久以前，在一个遥远的星系……一份题为“比特币：点对点电子现金系统”的神秘白皮书以笔名中本聪发布。
| 2018-09-21T16:42:00 | 2018-09-21T16:42:00 | 10,036 |
/article-10036-1.html
|
### 序幕
很久以前，在一个遥远的星系……一份题为“[比特币：点对点电子现金系统](http://bitcoin.org/bitcoin.pdf)”的神秘白皮书以笔名<ruby> 中本聪 <rt> Satoshi Nakamoto </rt></ruby>发布。该文件用他们自己的话说，<ruby> “不依赖于信任的电子交易系统” <rt> a system for electronic transactions without relying on trust <br/> </rt></ruby>。
时间是 2008 年 11 月，我们所说的遥远的星系就是互联网。这是比特币历史的开端。直到今天，没有人确切知道中本聪是谁。我们所知道的是，第一个开源比特币客户端于 2009 年 1 月发布，在接下来的几年中，中本聪积累了大约 100 万比特币，然后在 2010 年中期完全从比特币世界中消失。直到今天，他（或他们）庞大的比特币财富仍未受到影响，分布在几个已知的比特币账户中。截至 2017 年中期，这些比特币总价值约为 40 亿美元。
### 比特币的历史
2009 年推出的比特币是区块链技术的第一次真实应用。在接下来的五年里，区块链的历史几乎与比特币的历史同义。以下是此期间的粗略时间表：
### 以太坊的历史
2014 年是区块链历史上一个重要里程碑。在此之前，区块链技术的应用仅限于加密货币。尽管比特币协议已在该领域证明了自己，但它缺乏开发区块链应用程序所需的脚本语言，以拓展到加密货币外的应用领域。
Vitalik Buterin 多年来一直是比特币的重要发烧友，并且在 2012 年他 18 岁时已经共同创立了《<ruby> 比特币杂志 <rt> Bitcoin Magazine </rt></ruby>》！在他想更新原始比特币协议未获比特币社区同意后，Vitalik 就聚集了一个超级程序员团队，开发一个全新的区块链协议，其中包含所谓的<ruby> 智能合约 <rt> smart contract </rt></ruby>，允许程序员在其区块链中构建称作合约的脚本，并在满足某些条件时执行。Vitalik 将他的新区块链命名为<ruby> 以太坊 <rt> Ethereum </rt></ruby>。
在以太坊区块链上使用智能合约需要小额支付以太币，即以太坊的加密货币。这些小额支付称为“<ruby> 燃料 <rt> gas </rt></ruby>”，并奖励给“挖出了”包含该交易的数据块的计算机节点。智能合约的使用案例非常多样化，很可能在未来许多年中我们不会完全理解它的用处（就像 90 年代初期互联网刚兴起时，我们不知道 Facebook、YouTube 和 Skype 将怎样改变世界）。
一个有助于描述智能合约有用性的简单例子是去中心化彩票。在下面的示例中，开发了具有以下功能的智能合约并将其存储在以太坊区块链中：
* 任何人可以发送以太币给智能合约。
* 每 24 小时，智能合约随机选择一个贡献地址，并将合约中的所有以太币返回到该地址。
* 你贡献的以太币越多，获胜的机会就越高。
* 由于智能合约存储在以太坊区块链中，其内容是公开的，任何人都可以检查它以确保它不包含任何错误或蹊跷的逻辑。没有人（甚至是开发者）能够动存储在智能合约上的资金。从理论上讲，这样的彩票运营支出最小（只有燃料成本和创建者在智能合约中内置的其他费用）。这种彩票相比传统彩票，优势显著：
* 由于运营支出减少，获胜的几率可以大大提高。
* 整个系统是完全透明的，每个参与者将能够在参与彩票之前准确计算他们获胜的机会。
* 由于它是完全去中心化的，区块链彩票将不会面临破产以及许多其他外部风险因素。
* 支付是保证和即时的。
* 参与者是<ruby> 伪匿名 <rt> pseudo-anonymous </rt></ruby>的。
自 2014 年推出以来，以太坊区块链经历了一个显著的增长期，现在成为仅次于比特币的区块链。以下时间表显示了 2014 年以后比特币相关事件的历史。
### 未来会怎样
现在你已经了解了区块链的历史，让我们简单预测一下它的未来。如前所述，与传统的会计和记录保存方法相比，区块链应用程序的去中心化性质提供了显著的优势。在过去的 12 个月中，区块链技术向主流认可迈出了重要一步，数百家蓝筹公司在其基础设施上投入巨资（参见 [Finextra](https://www.finextra.com/newsarticle/29093/2016-wall-street-blockchain-investment-to-top-1bn)）。几乎所有主要的咨询公司都公开宣称他们看好区块链技术对一系列行业的潜在影响（[埃森哲](https://www.accenture.com/us-en/insight-perspectives-capital-markets-blockchain-future)、[路透社](http://www.reuters.com/article/us-banks-blockchain-accenture-idUSKBN1511OU)、[德勤](https://www2.deloitte.com/global/en/pages/financial-services/articles/gfsi-disruptive-innovation-blockchain.html)、[普华永道](http://www.pwc.com/us/en/energy-mining/exploring-the-disruptive-potential-of-decentralized-storage-and-peer-to-peer-transactions-in-the-energy-industry.html)），一些分析机构预测价格在未来十年价格会大幅上涨（[NewsBTC](http://www.newsbtc.com/2017/07/06/bitcoin-price-positive-future/)、[CNBC](http://www.cnbc.com/2017/05/31/bitcoin-price-forecast-hit-100000-in-10-years.html)，[Money Morning](https://moneymorning.com/2017/06/15/why-a-bitcoin-price-prediction-of-1-million-isnt-crazy/)）。虽然我们并没有拥有预测的水晶球，而且区块链的大规模使用肯定存在很多障碍，但这种技术的未来似乎比以往更加光明。
你喜欢这篇博文吗？我们是否错过了任何重要的区块链里程碑？您对区块链的未来有何看法？我们很乐意在下面的留言板上收到您的来信！我们的下一篇博文将为您提供我们称之为区块链生态系统的概述。希望能在那里见到你！
---
via: <https://www.myblockchainblog.com/blog/a-brief-history-of-blockchain>
作者：[Vegard Nordahl & Meghana Rao](https://www.myblockchainblog.com/?author=57ca44c0bebafb5698fc5e7d) 选题：[jasminepeng](https://github.com/jasminepeng) 译者：[jasminepeng](https://github.com/jasminepeng) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](/article-9986-1.html) 荣誉推出
|
Autotrash：一个自动清除旧垃圾的命令行工具
|
Sk
|
https://www.ostechnix.com/autotrash-a-cli-tool-to-automatically-purge-old-trashed-files/
|
它将清除超过指定天数的在回收站中的文件。你不需要清空回收站或执行 SHIFT+DELETE 以永久清除文件/文件夹。
|
/data/attachment/album/201809/22/133009txeehu4ejr47lrrj.png.thumb.jpg
|
/data/attachment/album/201809/22/133009txeehu4ejr47lrrj.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Autotrash",
"回收站",
"删除"
] |
分享
|
{
"viewnum": 6450,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
它将清除超过指定天数的在回收站中的文件。你不需要清空回收站或执行 SHIFT+DELETE 以永久清除文件/文件夹。
| 2018-09-22T13:30:07 | 2018-09-22T13:30:07 | 10,038 |
/article-10038-1.html
|
**Autotrash** 是一个命令行程序，它用于自动清除旧的已删除文件。它将清除超过指定天数的在回收站中的文件。你不需要清空回收站或执行 `SHIFT+DELETE` 以永久清除文件/文件夹。Autortrash 将处理回收站中的内容，并在特定时间段后自动删除它们。简而言之，Autotrash 永远不会让你的垃圾变得太大。
### 安装 Autotrash
Autotrash 默认存在于基于 Debian 系统的仓库中。要在 Debian、Ubuntu、Linux Mint 上安装 `autotrash`，请运行：
```
$ sudo apt-get install autotrash
```
在 Fedora 上：
```
$ sudo dnf install autotrash
```
对于 Arch linux 及其变体，你可以使用任何 AUR 助手程序， 如 [**Yay**](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/) 安装它。
```
$ yay -S autotrash-git
```
### 自动清除旧的垃圾文件
每当你运行 `autotrash` 时，它会扫描你的 `~/.local/share/Trash/info` 目录并读取 `.trashinfo` 以找出它们的删除日期。如果文件已在回收站中超过指定的日期，那么就会删除它们。
让我举几个例子。
要删除回收站中超过 30 天的文件，请运行：
```
$ autotrash -d 30
```
如上例所示，如果回收站中的文件超过 30 天，Autotrash 会自动将其从回收站中删除。你无需手动删除它们。只需将没用的文件放到回收站即可忘记。Autotrash 将处理已删除的文件。
以上命令仅处理当前登录用户的垃圾目录。如果要使 autotrash 处理所有用户的垃圾目录（不仅仅是在你的家目录中），请使用 `-t` 选项，如下所示。
```
$ autotrash -td 30
```
Autotrash 还允许你根据回收站可用容量或磁盘可用空间来删除已删除的文件。
例如，看下下面的例子：
```
$ autotrash --max-free 1024 -d 30
```
根据上面的命令，如果回收站的剩余的空间少于 **1GB**，那么 autotrash 将从回收站中清除超过 **30 天**的已删除文件。如果你的回收站空间不足，这可能很有用。
我们还可以从回收站中按最早的时间清除文件直到回收站至少有 1GB 的空间。
```
$ autotrash --min-free 1024
```
在这种情况下，对旧的已删除文件没有限制。
你可以将这两个选项（`--min-free` 和 `--max-free`）组合在一个命令中，如下所示。
```
$ autotrash --max-free 2048 --min-free 1024 -d 30
```
根据上面的命令，如果可用空间小于 **2GB**，`autotrash` 将读取回收站，接着关注容量。此时，删除超过 30 天的文件，如果少于 **1GB** 的可用空间，则删除更新的文件。
如你所见，所有命令都应由用户手动运行。你可能想知道，我该如何自动执行此任务？这很容易！只需将 `autotrash` 添加为 crontab 任务即可。现在，命令将在计划的时间自动运行，并根据定义的选项清除回收站中的文件。
要在 crontab 中添加这些命令，请运行：
```
$ crontab -e
```
添加任务，例如：
```
@daily /usr/bin/autotrash -d 30
```
现在，autotrash 将每天清除回收站中超过 30 天的文件。
有关计划任务的更多详细信息，请参阅以下链接。
* [Cron 任务的初学者指南]][2](https://www.ostechnix.com/a-beginners-guide-to-cron-jobs/)
* [如何在 Linux 中轻松安全地管理 Cron 作业]][3](https://www.ostechnix.com/how-to-easily-and-safely-manage-cron-jobs-in-linux/)
请注意，如果你无意中删除了任何重要文件，它们将在规定的日期后永久消失，所以请小心。
请参阅手册页以了解有关 Autotrash 的更多信息。
```
$ man autotrash
```
清空回收站或按 `SHIFT+DELETE` 永久删除 Linux 系统中没用的东西没什么大不了的。它只需要几秒钟。但是，如果你需要额外的程序来处理垃圾文件，Autotrash 可能会有所帮助。试一下，看看它是如何工作的。
就是这些了。希望这个有用。还有更多的好东西。
干杯!
---
via: <https://www.ostechnix.com/autotrash-a-cli-tool-to-automatically-purge-old-trashed-files/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
增强 Vim 编辑器，提高编辑效率
|
Girish Managoli
|
https://opensource.com/article/18/9/vi-editor-productivity-powerhouse
|
这 20 多个有用的命令可以增强你使用 Vim 的体验。
|
/data/attachment/album/201809/22/140748n5hmv7hvt95ch0vh.png.thumb.jpg
|
/data/attachment/album/201809/22/140748n5hmv7hvt95ch0vh.png
| true | false | true |
lujun9972
|
idea2act
|
apemost, wxy
| false |
[
"Vim"
] |
技术
|
{
"viewnum": 9749,
"commentnum": 1,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "123.139.73.56",
"message": "好，关于括号匹配方面，有没有谁知道怎么匹配sql server 里面的 begin end？",
"username": "我才是飞天 [Chrome 69.0|Windows 7]",
"date": "2018-09-24T12:33:11"
}
] |
[] |
这 20 多个有用的命令可以增强你使用 Vim 的体验。
| 2018-09-22T14:08:00 | 2018-09-22T14:08:00 | 10,039 |
/article-10039-1.html
|
>
> 这 20 多个有用的命令可以增强你使用 Vim 的体验。
>
>
>
*编者注：标题和文章最初称呼的 `vi` 编辑器，现已更新为编辑器的正确名称：`Vim`。*
`Vim` 作为一款功能强大、选项丰富的编辑器，为许多用户所热爱。本文介绍了一些在 `Vim` 中默认未启用但实际非常有用的选项。虽然可以在每个 `Vim` 会话中单独启用，但为了创建一个开箱即用的高效编辑环境，还是建议在 `Vim` 的配置文件中配置这些命令。
### 开始前的准备
这里所说的选项或配置均位于用户主目录中的 `Vim` 启动配置文件 `.vimrc`。 按照下面的说明在 `.vimrc` 中设置选项：
（注意：`vimrc` 文件也用于 `Linux` 中的全局配置，如 `/etc/vimrc` 或 `/etc/vim/vimrc`。本文所说的 `.vimrc` 均是指位于用户主目录中的 `.vimrc` 文件。）
Linux 系统中：
* 用 `Vim` 打开 `.vimrc` 文件： `vim ~/.vimrc`
* 复制本文最后的 `选项列表` 粘贴到 `.vimrc` 文件
* 保存并关闭 (`:wq`)
（LCTT 译注：此处不建议使用 `Vim` 编辑 `.vimrc` 文件，因为很可能无法粘贴成功，可以选择 `gedit` 编辑器编辑 `.vimrc` 文件。）
Windows 系统中：
* 首先，[安装 gvim](https://www.vim.org/download.php#pc)
* 打开 `gvim`
* 单击 “编辑” -> “启动设置”，打开 `_vimrc` 文件
* 复制本文最后的 “选项列表” 粘贴到 `_vimrc` 文件
* 单击 “文件” -> “保存”
（LCTT 译注：此处应注意不要使用 `Windows` 自带的记事本编辑该 `_vimrc` 文件，否则可能会因为行结束符不同而导致问题。）
下面，我们将深入研究提高 `Vim` 编辑效率的选项。主要分为以下几类：
1. 缩进 & 制表符
2. 显示 & 格式化
3. 搜索
4. 浏览 & 滚动
5. 拼写
6. 其他选项
### 1. 缩进 & 制表符
使 `Vim` 在创建新行的时候使用与上一行同样的缩进：
```
set autoindent
```
创建新行时使用智能缩进，主要用于 `C` 语言一类的程序。通常，打开 `smartindent` 时也应该打开 `autoindent`：
```
set smartindent
```
注意：`Vim` 具有语言感知功能，且其默认设置可以基于文件中的编程语言来改变配置以提高效率。有许多默认的配置选项，包括 `axs cindent`，`cinoptions`，`indentexpr` 等，没有在这里说明。 `syn` 是一个非常有用的命令，用于设置文件的语法以更改显示模式。
（LCTT 译注：这里的 `syn` 是指 `syntax`，可用于设置文件所用的编程语言，开启对应的语法高亮，以及执行自动事件 (`autocmd`)。）
设置文件里的制表符 `(TAB)` 的宽度（以空格的数量表示）：
```
set tabstop=4
```
设置移位操作 `>>` 或 `<<` 的缩进长度（以空格的数量表示）：
```
set shiftwidth=4
```
如果你更喜欢在编辑文件时使用空格而不是制表符，设置以下选项可以使 `Vim` 在你按下 `Tab` 键时用空格代替制表符。
```
set expandtab
```
注意：这可能会导致依赖于制表符的 `Python` 等编程语言出现问题。这时，你可以根据文件类型设置该选项（请参考 `autocmd`）。
### 2. 显示 & 格式化
要在每行的前面显示行号：
```
set number
```
要在文本行超过一定长度时自动换行：
```
set textwidth=80
```
要根据从窗口右侧向左数的列数来自动换行：
```
set wrapmargin=2
```
（LCTT 译注：如果 `textwidth` 选项不等于零，本选项无效。)
当光标遍历文件时经过括号时，高亮标识匹配的括号：
```
set showmatch
```
### 3. 搜索
高亮搜索内容的所有匹配位置：
```
set hlsearch
```
搜索过程中动态显示匹配内容：
```
set incsearch
```
搜索时忽略大小写：
```
set ignorecase
```
在打开 `ignorecase` 选项的条件下，搜索内容包含部分大写字符时，要使搜索大小写敏感：
```
set smartcase
```
例如，如果文件内容是：
```
test
Test
```
当打开 `ignorecase` 和 `smartcase` 选项时，搜索 `test` 时的突出显示：
>
> test
> Test
>
>
>
搜索 `Test` 时的突出显示：
>
> test
> Test
>
>
>
### 4. 浏览 & 滚动
为获得更好的视觉体验，你可能希望将光标放在窗口中间而不是第一行，以下选项使光标距窗口上下保留 5 行。
```
set scrolloff=5
```
一个例子：
第一张图中 `scrolloff=0`，第二张图中 `scrolloff=5`。
提示：如果你没有设置选项 `nowrap`，那么设置 `sidescrolloff` 将非常有用。
在 `Vim` 窗口底部显示一个永久状态栏，可以显示文件名、行号和列号等内容：
```
set laststatus=2
```
### 5. 拼写
`Vim` 有一个内置的拼写检查器，对于文本编辑和编码非常有用。`Vim` 可以识别文件类型并仅对代码中的注释进行拼写检查。使用下面的选项打开英语拼写检查：
```
set spell spelllang=en_us
```
（LCTT 译注：中文、日文或其它东亚语字符通常会在打开拼写检查时被标为拼写错误，因为拼写检查不支持这些语种，可以在 `spelllang` 选项中加入 `cjk` 来忽略这些错误标注。）
### 6. 其他选项
禁止创建备份文件：启用此选项后，`Vim` 将在覆盖文件前创建一个备份，文件成功写入后保留该备份。如果不想保留该备份文件，可以按下面的方式关闭：
```
set nobackup
```
禁止创建交换文件：启用此选项后，`Vim` 将在编辑该文件时创建一个交换文件。 交换文件用于在崩溃或发生使用冲突时恢复文件。交换文件是以 `.` 开头并以 `.swp` 结尾的隐藏文件。
```
set noswapfile
```
如果需要在同一个 `Vim` 窗口中编辑多个文件并进行切换。默认情况下，工作目录是打开的第一个文件的目录。而将工作目录自动切换到正在编辑的文件的目录是非常有用的。要自动切换工作目录：
```
set autochdir
```
`Vim` 自动维护编辑的历史记录，允许撤消更改。默认情况下，该历史记录仅在文件关闭之前有效。`Vim` 包含一个增强功能，使得即使在文件关闭后也可以维护撤消历史记录，这意味着即使在保存、关闭和重新打开文件后，也可以撤消之前的更改。历史记录文件是使用 `.un~` 扩展名保存的隐藏文件。
```
set undofile
```
错误信息响铃，只对错误信息起作用：
```
set errorbells
```
如果你愿意，还可以设置错误视觉提示：
```
set visualbell
```
### 惊喜
`Vim` 提供长格式和短格式命令，两种格式都可用于设置或取消选项配置。
`autoindent` 选项的长格式是：
```
set autoindent
```
`autoindent` 选项的短格式是：
```
set ai
```
要在不更改选项当前值的情况下查看其当前设置，可以在 `Vim` 的命令行上使用在末尾加上 `?` 的命令：
```
set autoindent?
```
在大多数选项前加上 `no` 前缀可以取消或关闭选项：
```
set noautoindent
```
可以为单独的文件配置选项，而不必修改全局配置文件。需要的话，请打开文件并输入 `:`，然后键入 `set`命令。这样的话，配置仅对当前的文件编辑会话有效。
使用命令行获取帮助：
```
:help autoindent
```
注意：此处列出的命令仅对 Linux 上的 Vim 7.4 版本和 Windows 上的 Vim 8.0 版本进行了测试。
这些有用的命令肯定会增强您的 `Vim` 使用体验。你会推荐哪些其他有用的命令?
### 选项列表
复制该选项列表粘贴到 `.vimrc` 文件中：
```
" Indentation & Tabs
set autoindent
set smartindent
set tabstop=4
set shiftwidth=4
set expandtab
set smarttab
" Display & format
set number
set textwidth=80
set wrapmargin=2
set showmatch
" Search
set hlsearch
set incsearch
set ignorecase
set smartcase
" Browse & Scroll
set scrolloff=5
set laststatus=2
" Spell
set spell spelllang=en_us
" Miscellaneous
set nobackup
set noswapfile
set autochdir
set undofile
set visualbell
set errorbells
```
---
via: <https://opensource.com/article/18/9/vi-editor-productivity-powerhouse>
作者：[Girish Managoli](https://opensource.com/users/gammay) 选题：[lujun9972](https://github.com/lujun9972) 译者：[idea2act](https://github.com/idea2act) 校对：[apemost](https://github.com/apemost), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
GNU GPL 许可证常见问题解答（七）
|
Fsf
|
https://www.gnu.org/licenses/gpl-faq.html
|
这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
|
/data/attachment/album/201809/22/142048o5q050hmzxuzuhkq.png.thumb.jpg
|
/data/attachment/album/201809/22/142048o5q050hmzxuzuhkq.png
| true | false | true |
薛亮
| false |
[
"GPL"
] |
开源智慧
|
{
"viewnum": 10368,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9826,
"displayorder": 0
}
] |
这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
| 2018-09-22T14:20:00 | 2018-09-22T14:20:00 | 10,040 |
/article-10040-1.html
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的[英文原文](https://www.gnu.org/licenses/gpl-faq.html)翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
1. [关于 GNU 项目、自由软件基金会（FSF）及其许可证的基本问题](/article-9062-1.html)
2. [对于 GNU 许可证的一般了解](/article-8834-1.html)
3. [在您的程序中使用 GNU 许可证](/article-8761-1.html)
4. [依据GNU许可证分发程序](/article-9222-1.html)
5. [在编写其他程序时采用依据 GNU 许可证发布的程序](/article-9448-1.html)
6. [将作品与依据 GNU 许可证发布的代码相结合](/article-9826-1.html)
7. 关于违反 GNU 许可证的问题
### 7 关于违反 GNU 许可证的问题
#### 7.1 如果发现了可能违反 GPL 许可证的行为，我该怎么办？
您应该[进行报告](https://www.gnu.org/licenses/gpl-violation.html)。 首先，尽可能检查事实。然后告诉发行者或版权所有者涉及的具体 GPL 程序。如果是自由软件基金会，请写信给 <license-violation@gnu.org>。此外，程序的维护者可能是版权所有者，他可能会告诉您如何联系版权所有者，因此将其报告给维护者。
#### 7.2 谁有权力执行 GPL 许可证？（同 1.10）
由于 GPL 是版权许可，软件的版权所有者将是有权执行 GPL 的人。如果您发现违反 GPL 的行为，您应该向遵循 GPL 的该软件的开发人员通报。他们是版权所有者，或与版权所有者有关。若要详细了解如何报告 GPL 违规，请参阅“[如果发现了可能违反 GPL 许可证的行为，我该怎么办？](https://www.gnu.org/licenses/gpl-faq.html#ReportingViolation)”。
#### 7.3 我听说有人依据另一个许可证获得了 GPL 程序的副本。这可能吗？
GNU GPL 不允许用户将其他许可证附加到程序。但是，程序的版权持有人可以依据几个不同的许可证并行发布。其中一个可能是 GNU GPL。
对于您的副本中的许可证来说，假设由版权所有者放置，并且您合法地获得该副本，则是适用于您的副本的许可证。
#### 7.4 遵循 GPL 的程序的开发者是否受 GPL 的约束？开发者的行为是否会违反 GPL？
严格来说，GPL 是开发者授予其他人使用、分发和更改程序的许可。开发者本身并不受其约束，所以无论开发者做什么，都不是 GPL 的“违规”。
但是，如果开发者做某些违反 GPL 的行为，那么开发者一定会失去在社区的道德地位。
#### 7.5 我刚刚发现一家公司有一份 GPL 程序的副本，获取该副本需支付费用。他们会因为不能在互联网上提供副本而违反 GPL 吗？（同 4.12）
不会，GPL 不要求任何人使用互联网进行分发。它也不要求任何人特意去再分发程序。而且（一个特殊情况之外），即使有人决定再分发该程序，GPL 也不会要求他必须特意向您或其他人分发副本。
GPL 要求的是，如果他愿意，他必须有权将副本分发给你。一旦版权所有者将程序的副本分发给某人，如果某人认为合适，那么该人可以将程序再分发给您或任何其他人。
#### 7.6 我可以在如果客户不继续支付订阅费用就停止运行的设备上使用遵循 GPL 的软件吗？
不可以。在这种情况下，继续支付费用的要求限制了用户运行程序的能力。 这是在 GPL 之上的额外要求，GPL 禁止这种行为。
#### 7.7 <ruby> “纠正” <rp> （ </rp> <rt> cure </rt> <rp> ） </rp></ruby>违反 GPL v3 的行为意味着什么？
纠正违规行为意味着调整您的做法以符合许可证的要求。
#### 7.8 如果有人在笔记本电脑上安装遵循 GPL 的软件，然后将笔记本电脑借给朋友，而不提供软件的源代码，他们是否违反了 GPL？
在我们调查这个问题的司法管辖区，这种借用不会被算作、<ruby> 传递 <rp> （ </rp> <rt> convey </rt> <rp> ） </rp></ruby>。笔记本电脑的所有者不会依据 GPL 承担任何义务。
#### 7.9 假设两家公司试图通过让一家公司发布已签约的软件，另一家公司发布仅运行第一家公司签约软件的用户产品，以此来规避提供安装信息的要求。这是否违反了 GPL v3？
是的。如果双方通过一起工作来逃避 GPL 的要求，就可以追究它们的侵权行为。这是特别真实的情形，因为<ruby> 传递 <rp> （ </rp> <rt> convey </rt> <rp> ） </rp></ruby>的定义明确地包括会使某人对二次侵权负责的活动。
---
译者介绍：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
Git 使用简介
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2018/7/introduction-using-git
|
我将向你介绍让 Git 的启动、运行，并和 GitHub 一起使用的基础知识。
|
/data/attachment/album/201809/22/193823zhuzopo5os1pnawo.png.thumb.jpg
|
/data/attachment/album/201809/22/193823zhuzopo5os1pnawo.png
| true | false | true |
lujun9972
|
distant1219
|
wxy
| false |
[
"Git",
"GitHub"
] |
软件开发
|
{
"viewnum": 6296,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我将向你介绍让 Git 的启动、运行，并和 GitHub 一起使用的基础知识。
| 2018-09-22T19:38:20 | 2018-09-22T19:38:20 | 10,041 |
/article-10041-1.html
|
>
> 我将向你介绍让 Git 的启动、运行，并和 GitHub 一起使用的基础知识。
>
>
>
如果你是一个开发者，那你应该熟悉许多开发工具。你已经花了多年时间来学习一种或者多种编程语言并打磨你的技巧。你可以熟练运用图形工具或者命令行工具开发。在你看来，没有任何事可以阻挡你。你的代码, 好像你的思想和你的手指一样，将会创建一个优雅的，完美评价的应用程序，并会风靡世界。
然而，如果你和其他人共同开发一个项目会发生什么呢？或者，你开发的应用程序变地越来越大，下一步你将如何去做？如果你想成功地和其他开发者合作，你定会想用一个分布式版本控制系统。使用这样一个系统，合作开发一个项目变得非常高效和可靠。这样的一个系统便是 [Git](https://git-scm.com/)。还有一个叫 [GitHub](https://github.com/) 的方便的存储仓库，用来存储你的项目代码，这样你的团队可以检查和修改代码。
我将向你介绍让 Git 的启动、运行，并和 GitHub 一起使用的基础知识，可以让你的应用程序的开发可以提升到一个新的水平。我将在 Ubuntu 18.04 上进行演示，因此如果您选择的发行版本不同，您只需要修改 Git 安装命令以适合你的发行版的软件包管理器。
### Git 和 GitHub
第一件事就是创建一个免费的 GitHub 账号，打开 [GitHub 注册页面](https://github.com/join?source=header-home)，然后填上需要的信息。完成这个之后，你就注备好开始安装 Git 了（这两件事谁先谁后都可以）。
安装 Git 非常简单，打开一个命令行终端，并输入命令：
```
sudo apt install git-all
```
这将会安装大量依赖包，但是你将了解使用 Git 和 GitHub 所需的一切。
附注：我使用 Git 来下载程序的安装源码。有许多时候，内置的软件管理器不提供某个软件，除了去第三方库中下载源码，我经常去这个软件项目的 Git 主页，像这样克隆：
```
git clone ADDRESS
```
“ADDRESS” 就是那个软件项目的 Git 主页。这样我就可以确保自己安装那个软件的最新发行版了。
### 创建一个本地仓库并添加一个文件
下一步就是在你的电脑里创建一个本地仓库（本文称之为 newproject，位于 `~/` 目录下），打开一个命令行终端，并输入下面的命令：
```
cd ~/
mkdir newproject
cd newproject
```
现在你需要初始化这个仓库。在 `~/newproject` 目录下，输入命令 `git init`，当命令运行完，你就可以看到一个刚刚创建的空的 Git 仓库了（图1）。
*图 1: 初始化完成的新仓库*
下一步就是往项目里添加文件。我们在项目根目录（`~/newproject`）输入下面的命令：
```
touch readme.txt
```
现在项目里多了个空文件。输入 `git status` 来验证 Git 已经检测到多了个新文件（图2）。
*图 2: Git 检测到新文件readme.txt*
即使 Git 检测到新的文件，但它并没有被真正的加入这个项目仓库。为此，你要输入下面的命令：
```
git add readme.txt
```
一旦完成这个命令，再输入 `git status` 命令，可以看到，`readme.txt` 已经是这个项目里的新文件了（图3）。
*图 3: 我们的文件已经被添加进临时环境*
### 第一次提交
当新文件添加进临时环境之后，我们现在就准备好创建第一个<ruby> 提交 <rt> commit </rt></ruby>了。什么是提交呢？简单的说，一个提交就是你更改的项目的文件的记录。创建一个提交也是非常简单的。但是，为提交包含一个描述信息非常重要。通过这样做，你可以添加有关该提交包含的内容的注释，比如你对文件做出的何种修改。然而，在这样做之前，我们需要告知 Git 我们的账户，输入以下命令：
```
git config --global user.email EMAIL
git config --global user.name “FULL NAME”
```
“EMAIL” 即你的 email 地址，“FULL NAME” 则是你的姓名。
现在你可以通过以下命令创建一个提交：
```
git commit -m “Descriptive Message”
```
“Descriptive Message” 即为你的提交的描述性信息。比如，当你第一个提交是提交一个 `readme.txt` 文件，你可以这样提交：
```
git commit -m “First draft of readme.txt file”
```
你可以看到输出表明一个文件已经修改，并且，为 `readme.txt` 创建了一个新的文件模式（图4）
*图4：提交成功*
### 创建分支并推送至 GitHub
分支是很重要的，它允许你在项目状态间中移动。假如，你想给你的应用创建一个新的特性。为了这样做，你创建了个新分支。一旦你完成你的新特性，你可以把这个新分支合并到你的主分支中去，使用以下命令创建一个新分支：
```
git checkout -b BRANCH
```
“BRANCH” 即为你新分支的名字，一旦执行完命令，输入 `git branch` 命令来查看是否创建了新分支（图5）
*图5:名为 featureX 的新分支*
接下来，我们需要在 GitHub 上创建一个仓库。 登录 GitHub 帐户，请单击帐户主页上的“New Repository”按钮。 填写必要的信息，然后单击 “Create repository”（图6）。
*图6:在 GitHub 上新建一个仓库*
在创建完一个仓库之后，你可以看到一个用于推送本地仓库的地址。若要推送，返回命令行窗口（`~/newproject` 目录中），输入以下命令：
```
git remote add origin URL
git push -u origin master
```
“URL” 即为我们 GitHub 上新建的仓库地址。
系统会提示您，输入 GitHub 的用户名和密码，一旦授权成功，你的项目将会被推送到 GitHub 仓库中。
### 拉取项目
如果你的同事改变了你们 GitHub 上项目的代码，并且已经合并那些更改，你可以拉取那些项目文件到你的本地机器，这样，你系统中的文件就可以和远程用户的文件保持匹配。你可以输入以下命令来做这件事（`~/newproject` 在目录中），
```
git pull origin master
```
以上的命令可以拉取任何新文件或修改过的文件到你的本地仓库。
### 基础
这就是从命令行使用 Git 来处理存储在 GitHub 上的项目的基础知识。 还有很多东西需要学习，所以我强烈建议你使用 `man git`，`man git-push` 和 `man git-pull` 命令来更深入地了解 `git` 命令可以做什么。
开发快乐！
了解更多关于 Linux 的 内容，请访问来自 Linux 基金会和 edX 的免费的 [Introduction to Linux](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/7/introduction-using-git>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[distant1219](https://github.com/distant1219) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何为 Linux 虚拟控制台配置鼠标支持
|
Sk
|
https://www.ostechnix.com/how-to-configure-mouse-support-for-linux-virtual-consoles/
|
它是一个守护程序，可以帮助你配置 Linux 虚拟控制台的鼠标支持。
|
/data/attachment/album/201809/23/214944r8snhp2rqpo2pqwq.png.thumb.jpg
|
/data/attachment/album/201809/23/214944r8snhp2rqpo2pqwq.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"鼠标"
] |
桌面应用
|
{
"viewnum": 6725,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
它是一个守护程序，可以帮助你配置 Linux 虚拟控制台的鼠标支持。
| 2018-09-23T21:49:41 | 2018-09-23T21:49:41 | 10,042 |
/article-10042-1.html
|
我使用 Oracle VirtualBox 来测试各种类 Unix 操作系统。我的大多数虚拟机都是<ruby> 无头 <rt> headless </rt></ruby>服务器，它们没有图形桌面环境。很长一段时间，我一直想知道如何在无头 Linux 服务器的基于文本的终端中使用鼠标。感谢 **GPM**，今天我了解到我们可以在虚拟控制台中使用鼠标进行复制和粘贴操作。 **GPM**，是<ruby> 通用鼠标 <rt> General Purpose Mouse </rt></ruby>的首字母缩写，它是一个守护程序，可以帮助你配置 Linux 虚拟控制台的鼠标支持。请不要将 GPM 与 **GDM**（<ruby> GNOME 显示管理器 <rt> GNOME Display manager </rt></ruby>）混淆。两者有完全不同的用途。
GPM 在以下场景中特别有用：
* 新的 Linux 服务器安装或默认情况下不能或不使用 X Windows 的系统，如 Arch Linux 和 Gentoo。
* 在虚拟终端/控制台中使用复制/粘贴操作。
* 在基于文本的编辑器和浏览器中使用复制/粘贴（例如，emacs、lynx）。
* 在文本文件管理器中使用复制/粘贴（例如 Ranger、Midnight commander）。
在这个简短的教程中，我们将看到如何在类 Unix 操作系统中在基于文本的终端中使用鼠标。
### 安装 GPM
要在纯文本 Linux 系统中启用鼠标支持，请安装 GPM 包。它在大多数 Linux 发行版的默认仓库中都有。
在 Arch Linux 及其变体如 Antergos、Manjaro Linux 上，运行以下命令来安装 GPM：
```
$ sudo pacman -S gpm
```
在 Debian、Ubuntu、Linux Mint 中：
```
$ sudo apt install gpm
```
在 Fedora 上：
```
$ sudo dnf install gpm
```
在 openSUSE 上：
```
$ sudo zypper install gpm
```
安装后，使用以下命令启用并启动 GPM 服务：
```
$ sudo systemctl enable gpm
$ sudo systemctl start gpm
```
在基于 Debian 的系统中，gpm 服务将在你安装后自动启动，因此你无需如上所示手动启动服务。
### 为 Linux 虚拟控制台配置鼠标支持
无需特殊配置。GPM 将在你安装并启动 gpm 服务后立即开始工作。
在安装 GPM 之前，看下我的 Ubuntu 18.04 LTS 服务器的屏幕截图：
正如你在上面的截图中看到的，我的 Ubuntu 18.04 LTS 无头服务器中没有可见的鼠标指针。只有一个闪烁的光标，它不能让我选择文本，使用鼠标复制/粘贴文本。在仅限 CLI 的 Linux 服务器中，鼠标根本没用。
在安装 GPM 后查看 Ubuntu 18.04 LTS 服务器的以下截图：
看见了吗？我现在可以选择文字了。
要选择，复制和粘贴文本，请执行以下操作：
* 要选择文本，请按下鼠标左键并拖动鼠标。
* 选择文本后，放开鼠标左键，并按下中键在同一个或另一个控制台中粘贴文本。
* 右键用于扩展选择，就像在 `xterm` 中。
* 如果你使用的是双键鼠标，请使用右键粘贴文本。
就这么简单！
就像我已经说过的那样，GPM 工作得很好，并且不需要额外的配置。以下是 GPM 配置文件 `/etc/gpm.conf`（或在某些发行版中是 `/etc/conf.d/gpm`）的示例内容：
```
# protected from evaluation (i.e. by quoting them).
#
# This file is used by /etc/init.d/gpm and can be modified by
# "dpkg-reconfigure gpm" or by hand at your option.
#
device=/dev/input/mice
responsiveness=
repeat_type=none
type=exps2
append=''
sample_rate=
```
在我的例子中，我使用 USB 鼠标。如果你使用的是其他鼠标，则可能需要更改 `device=/dev/input/mice` 和 `type=exps2` 参数的值。
有关更多详细信息，请参阅手册页。
```
$ man gpm
```
就是这些了。希望这个有用。还有更多的好东西。敬请期待！
干杯!
---
via: <https://www.ostechnix.com/how-to-configure-mouse-support-for-linux-virtual-consoles/>
作者：[SK](https://www.ostechnix.com/author/sk/)
选题：[lujun9972](https://github.com/lujun9972)
译者：[geekpi](https://github.com/geekpi)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 mDNS 在局域网中轻松发现系统
|
Paul W. Frields
|
https://fedoramagazine.org/find-systems-easily-lan-mdns/
|
mDNS（多播 DNS）允许系统在局域网中广播查询其他资源的名称。
|
/data/attachment/album/201809/23/220646civ0wdw1z9mt9100.jpg.thumb.jpg
|
/data/attachment/album/201809/23/220646civ0wdw1z9mt9100.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"mDNS",
"零配置系统"
] |
技术
|
{
"viewnum": 19065,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
mDNS（多播 DNS）允许系统在局域网中广播查询其他资源的名称。
| 2018-09-23T22:06:42 | 2018-09-23T22:06:42 | 10,043 |
/article-10043-1.html
|
mDNS（<ruby> 多播 DNS <rt> Multicast DNS </rt></ruby>）允许系统在局域网中广播查询其他资源的名称。Fedora 用户经常在没有复杂名称服务的路由器上接有多个 Linux 系统。在这种情况下，mDNS 允许你按名称与多个系统通信 —— 多数情况下不用路由器。你也不必在所有本地系统上同步类似 `/etc/hosts` 之类的文件。本文介绍如何设置它。
mDNS 是一个零配置网络服务，它已经诞生了很长一段时间。Fedora Workstation 带有零配置系统 Avahi（它包含 mDNS）。 （mDNS 也是 Bonjour 的一部分，可在 Mac OS 上找到。）
本文假设你有两个系统运行受支持的 Fedora 版本（27 或 28）。它们的主机名是 castor 和 pollux。
### 安装包
确保系统上安装了 nss-mdns 和 avahi 软件包。你可能是不同的版本，这也没问题：
```
$ rpm -q nss-mdns avahi
nss-mdns-0.14.1-1.fc28.x86_64
avahi-0.7-13.fc28.x86_64
```
Fedora Workstation 默认提供这两个包。如果不存在，请安装它们：
```
$ sudo dnf install nss-mdns avahi
```
确保 `avahi-daemon.service` 单元已启用并正在运行。同样，这是 Fedora Workstation 的默认设置。
```
$ sudo systemctl enable --now avahi-daemon.service
```
虽然是可选的，但你可能还需要安装 avahi-tools 软件包。该软件包包括许多方便的程序，用于检查系统上的零配置服务的工作情况。使用这个 `sudo` 命令：
```
$ sudo dnf install avahi-tools
```
`/etc/nsswitch.conf` 控制系统使用哪个服务用于解析，以及它们的顺序。你应该在那个文件中看到这样的一行：
```
hosts: files mdns4_minimal [NOTFOUND=return] dns myhostname
```
注意命令 `mdns4_minimal [NOTFOUND=return]`。它们告诉你的系统使用多播 DNS 解析程序将主机名解析为 IP 地址。即使该服务有效，如果名称无法解析，也会尝试其余服务。
如果你没有看到与此类似的配置，则可以（以 root 用户身份）对其进行编辑。但是，nss-mdns 包会为你处理此问题。如果你对自己编辑它感到不舒服，请删除并重新安装该软件包以修复该文件。
在**两个系统**中执行同样的步骤 。
### 设置主机名并测试
现在你已完成常见的配置工作，请使用以下方法之一设置每个主机的名称：
1. 如果你正在使用 Fedora Workstation，[你可以使用这个步骤](https://fedoramagazine.org/set-hostname-fedora/)。
2. 如果没有，请使用 `hostnamectl` 来做。在第一台机器上这么做：`$ hostnamectl set-hostname castor`。
3. 你还可以编辑 `/etc/avahi/avahi-daemon.conf`，删除主机名设置行上的注释，并在那里设置名称。但是，默认情况下，Avahi 使用系统提供的主机名，因此你**不应该**需要此方法。
接下来，重启 Avahi 守护进程，以便它接收更改：
```
$ sudo systemctl restart avahi-daemon.service
```
然后正确设置另一台机器：
```
$ hostnamectl set-hostname pollux
$ sudo systemctl restart avahi-daemon.service
```
只要你的路由器没有禁止 mDNS 流量，你现在应该能够登录到 castor 并 ping 通另一台机器。你应该使用默认的 .local 域名，以便解析正常工作：
```
$ ping pollux.local
PING pollux.local (192.168.0.1) 56(84) bytes of data.
64 bytes from 192.168.0.1 (192.168.0.1): icmp_seq=1 ttl=64 time=3.17 ms
64 bytes from 192.168.0.1 (192.168.0.1): icmp_seq=2 ttl=64 time=1.24 ms
...
```
如果你在 pollux `ping castor.local`，同样的技巧也适用。现在在网络中访问你的系统更方便了！
此外，如果你的路由器也支持这个服务，请不要感到惊讶。现代 WiFi 和有线路由器通常提供这些服务，以使消费者的生活更轻松。
此过程适用于大多数系统。但是，如果遇到麻烦，请使用 avahi-browse 和 avahi-tools 软件包中的其他工具来查看可用的服务。
---
via: <https://fedoramagazine.org/find-systems-easily-lan-mdns/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
最好的 3 个开源 JavaScript 图表库
|
Dr.michael J.garbade
|
https://opensource.com/article/18/9/open-source-javascript-chart-libraries
|
图表及其它可视化方式让传递数据的信息变得更简单。
|
/data/attachment/album/201809/24/075456lvopy2hhmrhljlov.jpg.thumb.jpg
|
/data/attachment/album/201809/24/075456lvopy2hhmrhljlov.jpg
| true | false | true |
lujun9972
|
BriFuture
|
wxy
| false |
[
"图表",
"JavaScript"
] |
分享
|
{
"viewnum": 6977,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
图表及其它可视化方式让传递数据的信息变得更简单。
| 2018-09-24T07:54:53 | 2018-09-24T07:54:53 | 10,044 |
/article-10044-1.html
|
>
> 图表及其它可视化方式让传递数据的信息变得更简单。
>
>
>
对于数据可视化和制作精美网站来说，图表和图形很重要。视觉上的展示让分析大块数据及传递信息变得更简单。JavaScript 图表库能让数据以极好的、易于理解的和交互的方式进行可视化，还能够优化你的网站设计。
本文会带你学习最好的 3 个开源 JavaScript 图表库。
### 1、 Chart.js
[Chart.js](https://www.chartjs.org/) 是一个开源的 JavaScript 库，你可以在自己的应用中用它创建生动美丽和交互式的图表。使用它需要遵循 MIT 协议。
使用 Chart.js，你可以创建各种各样令人印象深刻的图表和图形，包括条形图、折线图、范围图、线性标度和散点图。它可以响应各种设备，使用 HTML5 Canvas 元素进行绘制。
示例代码如下，它使用该库绘制了一个条形图。本例中我们使用 Chart.js 的内容分发网络（CDN）来包含这个库。注意这里使用的数据仅用于展示。
```
<!DOCTYPE html>
<html>
<head>
<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.5.0/Chart.min.js"></script>
</head>
<body>
<canvas id="bar-chart" width=300" height="150"></canvas>
<script>
new Chart(document.getElementById("bar-chart"), {
type: 'bar',
data: {
labels: ["North America", "Latin America", "Europe", "Asia", "Africa"],
datasets: [
{
label: "Number of developers (millions)",
backgroundColor: ["red", "blue","yellow","green","pink"],
data: [7,4,6,9,3]
}
]
},
options: {
legend: { display: false },
title: {
display: true,
text: 'Number of Developers in Every Continent'
},
scales: {
yAxes: [{
ticks: {
beginAtZero:true
}
}]
}
}
});
</script>
</body>
</html>
```
如你所见，通过设置 `type` 和 `bar` 来构造条形图。你可以把条形体的方向改成其他类型 —— 比如把 `type` 设置成 `horizontalBar`。
在 `backgroundColor` 数组参数中提供颜色类型，就可以设置条形图的颜色。
颜色被分配给关联数组中相同索引的标签和数据。例如，第二个标签 “Latin American”，颜色会是 “蓝色（blue）”（第二个颜色），数值是 4（data 中的第二个数字）。
代码的执行结果如下。
### 2、 Chartist.js
[Chartist.js](https://gionkunz.github.io/chartist-js/) 是一个简单的 JavaScript 动画库，你能够自制美丽的响应式图表，或者进行其他创作。使用它需要遵循 WTFPL 或者 MIT 协议。
这个库是由一些对现有图表工具不满的开发者进行开发的，它可以为设计师或程序员提供美妙的功能。
在项目中包含 Chartist.js 库后，你可以使用它们来创建各式各样的图表，包括动画，条形图和折线图。它使用 SVG 来动态渲染图表。
这里是使用该库绘制一个饼图的例子。
```
<!DOCTYPE html>
<html>
<head>
<link href="https//cdn.jsdelivr.net/chartist.js/latest/chartist.min.css" rel="stylesheet" type="text/css" />
<style>
.ct-series-a .ct-slice-pie {
fill: hsl(100, 20%, 50%); /* filling pie slices */
stroke: white; /*giving pie slices outline */
stroke-width: 5px; /* outline width */
}
.ct-series-b .ct-slice-pie {
fill: hsl(10, 40%, 60%);
stroke: white;
stroke-width: 5px;
}
.ct-series-c .ct-slice-pie {
fill: hsl(120, 30%, 80%);
stroke: white;
stroke-width: 5px;
}
.ct-series-d .ct-slice-pie {
fill: hsl(90, 70%, 30%);
stroke: white;
stroke-width: 5px;
}
.ct-series-e .ct-slice-pie {
fill: hsl(60, 140%, 20%);
stroke: white;
stroke-width: 5px;
}
</style>
</head>
<body>
<div class="ct-chart ct-golden-section"></div>
<script src="https://cdn.jsdelivr.net/chartist.js/latest/chartist.min.js"></script>
<script>
var data = {
series: [45, 35, 20]
};
var sum = function(a, b) { return a + b };
new Chartist.Pie('.ct-chart', data, {
labelInterpolationFnc: function(value) {
return Math.round(value / data.series.reduce(sum) * 100) + '%';
}
});
</script>
</body>
</html>
```
使用 Chartist JavaScript 库，你可以使用各种预先构建好的 CSS 样式，而不是在项目中指定各种与样式相关的部分。你可以使用这些样式来设置已创建的图表的外观。
比如，预创建的 CSS 类 `.ct-chart` 是用来构建饼状图的容器。还有 `.ct-golden-section` 类可用于获取纵横比，它基于响应式设计进行缩放，帮你解决了计算固定尺寸的麻烦。Chartist 还提供了其它类别的比例容器，你可以在自己的项目中使用它们。
为了给各个扇形设置样式，可以使用默认的 `.ct-serials-a` 类。字母 `a` 是根据系列的数量变化的（a、b、c，等等），因此它与每个要设置样式的扇形相对应。
`Chartist.Pie` 方法用来创建一个饼状图。要创建另一种类型的图表，比如折线图，请使用 `Chartist.Line`。
代码的执行结果如下。
### 3、 D3.js
[D3.js](https://d3js.org/) 是另一个好用的开源 JavaScript 图表库。使用它需要遵循 BSD 许可证。D3 的主要用途是，根据提供的数据，处理和添加文档的交互功能，。
借助这个 3D 动画库，你可以通过 HTML5、SVG 和 CSS 来可视化你的数据，并且让你的网站变得更精美。更重要的是，使用 D3，你可以把数据绑定到文档对象模型（DOM）上，然后使用基于数据的函数改变文档。
示例代码如下，它使用该库绘制了一个简单的条形图。
```
<!DOCTYPE html>
<html>
<head>
<style>
.chart div {
font: 15px sans-serif;
background-color: lightblue;
text-align: right;
padding:5px;
margin:5px;
color: white;
font-weight: bold;
}
</style>
</head>
<body>
<div class="chart"></div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/5.5.0/d3.min.js"></script>
<script>
var data = [342,222,169,259,173];
d3.select(".chart")
.selectAll("div")
.data(data)
.enter()
.append("div")
.style("width", function(d){ return d + "px"; })
.text(function(d) { return d; });
</script>
</body>
</html>
```
使用 D3 库的主要概念是应用 CSS 样式选择器来定位 DOM 节点，然后对其执行操作，就像其它的 DOM 框架，比如 JQuery。
将数据绑定到文档上后，.`enter()` 函数会被调用，为即将到来的数据构建新的节点。所有在 .`enter()` 之后调用的方法会为数据中的每一个项目调用一次。
代码的执行结果如下。
### 总结
[JavaScript](https://www.liveedu.tv/guides/programming/javascript/) 图表库提供了强大的工具，你可以将自己的网络资源进行数据可视化。通过这三个开源库，你可以把自己的网站变得更好看，更容易使用。
你知道其它强大的用于创造 JavaScript 动画效果的前端库吗？请在下方的评论区留言分享。
---
via: <https://opensource.com/article/18/9/open-source-javascript-chart-libraries>
作者：[Dr.Michael J.Garbade](https://opensource.com/users/drmjg) 选题：[lujun9972](https://github.com/lujun9972) 译者：[BriFuture](https://github.com/brifuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
何谓开源编程？
|
Jim Salter
|
https://opensource.com/article/18/3/what-open-source-programming
|
开源就是丢一些代码到 GitHub 上。了解一下它是什么，以及不是什么？
|
/data/attachment/album/201809/25/145810p6v1de6m6l6t6em6.jpg.thumb.jpg
|
/data/attachment/album/201809/25/145810p6v1de6m6l6t6em6.jpg
| true | false | true |
Valoniakim
|
wxy, pityonline
| false |
[
"开源"
] |
观点
|
{
"viewnum": 3694,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
开源就是丢一些代码到 GitHub 上。了解一下它是什么，以及不是什么？
| 2018-09-25T14:58:05 | 2018-09-25T14:58:05 | 10,045 |
/article-10045-1.html
|
>
> 开源就是丢一些代码到 GitHub 上。了解一下它是什么，以及不是什么？
>
>
>
最简单的来说，开源编程就是编写一些大家可以随意取用、修改的代码。但你肯定听过关于 Go 语言的那个老笑话，说 Go 语言“简单到看一眼就可以明白规则，但需要一辈子去学会运用它”。其实写开源代码也是这样的。往 GitHub、Bitbucket、SourceForge 等网站或者是你自己的博客或网站上丢几行代码不是难事，但想要卓有成效，还需要个人的努力付出和高瞻远瞩。
### 我们对开源编程的误解
首先我要说清楚一点：把你的代码放在 GitHub 的公开仓库中并不意味着把你的代码开源了。在几乎全世界，根本不用创作者做什么，只要作品形成，版权就随之而生了。在创作者进行授权之前，只有作者可以行使版权相关的权力。未经创作者授权的代码，不论有多少人在使用，都是一颗定时炸弹，只有愚蠢的人才会去用它。
有些创作者很善良，认为“很明显我的代码是免费提供给大家使用的。”，他也并不想起诉那些用了他的代码的人，但这并不意味着这些代码可以放心使用。不论在你眼中创作者们多么善良，他们都 *有权力* 起诉任何使用、修改代码，或未经明确授权就将代码嵌入的人。
很明显，你不应该在没有指定开源许可证的情况下将你的源代码发布到网上然后期望别人使用它并为其做出贡献。我建议你也尽量避免使用这种代码，甚至疑似未授权的也不要使用。如果你开发了一个函数和例程，它和之前一个疑似未授权代码很像，源代码作者就可以对你就侵权提起诉讼。
举个例子，Jill Schmill 写了 AwesomeLib 然后未明确授权就把它放到了 GitHub 上，就算 Jill Schmill 不起诉任何人，只要她把 AwesomeLib 的完整版权都卖给 EvilCorp，EvilCorp 就会起诉之前违规使用这段代码的人。这种行为就好像是埋下了计算机安全隐患，总有一天会为人所用。
没有许可证的代码的危险的，切记。
### 选择恰当的开源许可证
假设你正要写一个新程序，而且打算让人们以开源的方式使用它，你需要做的就是选择最贴合你需求的[许可证](https://opensource.com/tags/licensing)。和宣传中说的一样，你可以从 GitHub 所支持的 [choosealicense.com](https://choosealicense.com/) 开始。这个网站设计得像个简单的问卷，特别方便快捷，点几下就能找到合适的许可证。
警示：在选择许可证时不要过于自负，如果你选的是 [Apache 许可证](https://choosealicense.com/licenses/apache-2.0/)或者 [GPLv3](https://choosealicense.com/licenses/gpl-3.0/) 这种广为使用的许可证，人们很容易理解他们和你都有什么权利，你也不需要请律师来排查其中的漏洞。你选择的许可证使用的人越少，带来的麻烦就越多。
最重要的一点是： *千万不要试图自己制造许可证！* 自己制造许可证会给大家带来更多的困惑和困扰，不要这样做。如果在现有的许可证中确实找不到你需要的条款，你可以在现有的许可证中附加上你的要求，并且重点标注出来，提醒使用者们注意。
我知道有些人会站出来说：“我才懒得管什么许可证，我已经把代码发到<ruby> 公开领域 <rt> public domain </rt></ruby>了。”但问题是，公开领域的法律效力并不是受全世界认可的。在不同的国家，公开领域的效力和表现形式不同。在有些国家的政府管控下，你甚至不可以把自己的源代码发到公开领域。万幸，[Unlicense](https://choosealicense.com/licenses/unlicense/) 可以弥补这些漏洞，它语言简洁，使用几个词清楚地描述了“就把它放到公开领域”，但其效力为全世界认可。
### 怎样引入许可证
确定使用哪个许可证之后，你需要清晰而无疑义地指定它。如果你是在 GitHub、GitLab 或 BitBucket 这几个网站发布，你需要构建很多个文件夹，在根文件夹中，你应把许可证创建为一个以 `LICENSE.txt` 命名的明文文件。
创建 `LICENSE.txt` 这个文件之后还有其它事要做。你需要在每个重要文件的头部添加注释块来申明许可证。如果你使用的是一个现有的许可证，这一步对你来说十分简便。一个 `# 项目名 (c)2018 作者名，GPLv3 许可证，详情见 https://www.gnu.org/licenses/gpl-3.0.en.html` 这样的注释块比隐约指代的许可证的效力要强得多。
如果你是要发布在自己的网站上，步骤也差不多。先创建 `LICENSE.txt` 文件，放入许可证，再表明许可证出处。
### 开源代码的不同之处
开源代码和专有代码的一个主要区别是开源代码写出来就是为了给别人看的。我是个 40 多岁的系统管理员，已经写过许许多多的代码。最开始我写代码是为了工作，为了解决公司的问题，所以其中大部分代码都是专有代码。这种代码的目的很简单，只要能在特定场合通过特定方式发挥作用就行。
开源代码则大不相同。在写开源代码时，你知道它可能会被用于各种各样的环境中。也许你的用例的环境条件很局限，但你仍旧希望它能在各种环境下发挥理想的效果。不同的人使用这些代码时会出现各种用例，你会看到各类冲突，还有你没有考虑过的思路。虽然代码不一定要满足所有人，但至少应该得体地处理他们遇到的问题，就算解决不了，也可以转换回常见的逻辑，不会给使用者添麻烦。（例如“第 583 行出现零除错误”就不能作为错误地提供命令行参数的响应结果）
你的源代码也可能逼疯你，尤其是在你一遍又一遍地修改错误的函数或是子过程后，终于出现了你希望的结果，这时你不会叹口气就继续下一个任务，你会把过程清理干净，因为你不会愿意别人看出你一遍遍尝试的痕迹。比如你会把 `$variable`、`$lol` 全都换成有意义的 `$iterationcounter` 和 `$modelname`。这意味着你要认真专业地进行注释（尽管对于你所处的背景知识热度来说它并不难懂），因为你期望有更多的人可以使用你的代码。
这个过程难免有些痛苦沮丧，毕竟这不是你常做的事，会有些不习惯。但它会使你成为一位更好的程序员，也会让你的代码升华。即使你的项目只有你一位贡献者，清理代码也会节约你后期的很多工作，相信我一年后你再看你的 app 代码时，你会庆幸自己写下的是 `$modelname`，还有清晰的注释，而不是什么不知名的数列，甚至连 `$lol` 也不是。
### 你并不是为你一人而写
开源的真正核心并不是那些代码，而是社区。更大的社区的项目维持时间更长，也更容易为人们所接受。因此不仅要加入社区，还要多多为社区发展贡献思路，让自己的项目能够为社区所用。
蝙蝠侠为了完成目标暗中独自花了很大功夫，你用不着这样，你可以登录 Twitter、Reddit，或者给你项目的相关人士发邮件，发布你正在筹备新项目的消息，仔细聊聊项目的设计初衷和你的计划，让大家一起帮忙，向大家征集数据输入，类似的使用案例，把这些信息整合起来，用在你的代码里。你不用接受所有的建议和请求，但你要对它有个大概把握，这样在你之后完善时可以躲过一些陷阱。
发布了首次通告这个过程还不算完整。如果你希望大家能够接受你的作品并且使用它，你就要以此为初衷来设计。公众说不定可以帮到你，你不必对公开这件事如临大敌。所以不要闭门造车，既然你是为大家而写，那就开设一个真实、公开的项目，想象你在社区的帮助和监督下，认真地一步步完成它。
### 建立项目的方式
你可以在 GitHub、GitLab 或 BitBucket 上免费注册账号来管理你的项目。注册之后，创建知识库，建立 `README` 文件，分配一个许可证，一步步写入代码。这样可以帮你建立好习惯，让你之后和现实中的团队一起工作时，也能目的清晰地朝着目标稳妥地开展工作。这样你做得越久，就越有兴趣 —— 通常会有用户先对你的项目产生兴趣。
用户会开始提一些问题，这会让你开心也会让你不爽，你应该亲切礼貌地对待他们，就算他们很多人对项目有很多误解甚至根本不知道你的项目做的是什么，你也应该礼貌专业地对待。一方面，你可以引导他们，让他们了解你在干什么。另一方面，他们也会慢慢地将你带入更大的社区。
如果你的项目很受用户青睐，总会有高级开发者出现，并表示出兴趣。这也许是好事，也可能激怒你。最开始你可能只会做简单的问题修复，但总有一天你会收到拉取请求，有可能是硬编码或特殊用例（可能会让项目变得难以维护），它可能改变你项目的作用域，甚至改变你项目的初衷。你需要学会分辨哪个有贡献，根据这个决定合并哪个，婉拒哪个。
### 我们为什么要开源？
开源听起来任务繁重，它也确实是这样。但它对你也有很多好处。它可以在无形之中磨练你，让你写出纯净持久的代码，也教会你与人沟通，团队协作。对于一个志向远大的专业开发者来说，它是最好的简历素材。你的未来雇主很有可能点开你的仓库，了解你的能力范围；而社区项目的开发者也有可能给你带来工作。
最后，为开源工作，意味着个人的提升，因为你在做的事不是为了你一个人，这比养活自己重要得多。
---
via: <https://opensource.com/article/18/3/what-open-source-programming>
作者：[Jim Salter](https://opensource.com/users/jim-salter) 译者：[Valoniakim](https://github.com/Valoniakim) 校对：[wxy](https://github.com/wxy)、[pityonline](https://github.com/pityonline)
本文由 [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.