在我们另一篇文章中，我带您领略了一下什么是 xfs，xfs 的相关特性等内容。本文我们来看一些常用的 xfs 管理命令。我们将会通过几个例子来讲解如何创建 xfs 文件系统，如何对 xfs 文件系统进行扩容，如何检测并修复 xfs 文件系统。

创建 XFS 文件系统

mkfs.xfs 命令用来创建 xfs 文件系统。无需任何特别的参数，其输出如下：

root@kerneltalks # mkfs.xfs /dev/xvdf
meta-data=/dev/xvdf              isize=512    agcount=4, agsize=1310720 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=0, sparse=0
data     =                       bsize=4096   blocks=5242880, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal log           bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

注意：一旦 XFS 文件系统创建完毕就不能在缩容而只能进行扩容了。

调整 XFS 文件系统容量

你只能对 XFS 进行扩容而不能缩容。我们使用 xfs_growfs 来进行扩容。你需要使用 -D 参数指定挂载点的新容量。-D 接受一个数字的参数，指定文件系统块的数量。若你没有提供 -D 参数，则 xfs_growfs 会将文件系统扩到最大。

root@kerneltalks # xfs_growfs /dev/xvdf -D 256
meta-data=/dev/xvdf              isize=512    agcount=4, agsize=720896 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=0 spinodes=0
data     =                       bsize=4096   blocks=2883584, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal               bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
data size 256 too small, old size is 2883584

观察上面的输出中的最后一行。由于我分配的容量要小于现在的容量。它告诉你不能缩减 XFS 文件系统。你只能对它进行扩展。

root@kerneltalks #  xfs_growfs /dev/xvdf -D 2883840
meta-data=/dev/xvdf              isize=512    agcount=4, agsize=720896 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=0 spinodes=0
data     =                       bsize=4096   blocks=2883584, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal               bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0
data blocks changed from 2883584 to 2883840

现在我多分配了 1GB 的空间，而且也成功地扩增了容量。

1GB 块的计算方式：

当前文件系统 bsize 为 4096，意思是块的大小为 4MB。我们需要 1GB，也就是 256 个块。因此在当前块数，2883584 上加上 256 得到 2883840。因此我为 -D 传递参数 2883840。

修复 XFS 文件系统

可以使用 xfs_repair 命令进行文件系统一致性检查和修复。使用 -n 参数则并不对文件系统做出什么实质性的修改。它只会搜索并报告要做哪些修改。若不带 -n 参数，则会修改文件系统以保证文件系统的纯净。

请注意，在检查之前，你需要先卸载 XFS 文件系统。否则会报错。

root@kerneltalks # xfs_repair -n /dev/xvdf
xfs_repair: /dev/xvdf contains a mounted filesystem
xfs_repair: /dev/xvdf contains a mounted and writable filesystem

fatal error -- couldn't initialize XFS library

卸载后运行检查命令。

root@kerneltalks # xfs_repair -n /dev/xvdf
Phase 1 - find and verify superblock...
Phase 2 - using internal log
        - zero log...
        - scan filesystem freespace and inode maps...
        - found root inode chunk
Phase 3 - for each AG...
        - scan (but don't clear) agi unlinked lists...
        - process known inodes and perform inode discovery...
        - agno = 0
        - agno = 1
        - agno = 2
        - agno = 3
        - agno = 4
        - process newly discovered inodes...
Phase 4 - check for duplicate blocks...
        - setting up duplicate extent list...
        - check for inodes claiming duplicate blocks...
        - agno = 0
        - agno = 1
        - agno = 2
        - agno = 3
        - agno = 4
No modify flag set, skipping phase 5
Phase 6 - check inode connectivity...
        - traversing filesystem ...
        - traversal finished ...
        - moving disconnected inodes to lost+found ...
Phase 7 - verify link counts...
No modify flag set, skipping filesystem flush and exiting.

你可以看到，命令在每个阶段都显示出了为了文件系统变得健康可能做出的修改。若你希望命令在扫描时实际应用这些修改，则不带任何参数运行命令即可。

root @ kerneltalks # xfs_repair /dev/xvdf

Phase 1 - find and verify superblock . . .
Phase 2 - using internal log
        - zero log . . .
        - scan filesystem freespace and inode maps . . .
        - found root inode chunk
Phase 3 - for each AG . . . 
        - scan and clear agi unlinked lists . . .
        - process known inodes and perform inode discovery . . .
        - agno = 0 
        - agno = 1
        - agno = 2
        - agno = 3
        - agno = 4
        - process newly discovered inodes . . . 
Phase 4 - check for duplicate blocks . . .
        - setting up duplicate extent list . . .
        - check for inodes claiming duplicate blocks . . .
        - agno = 0
        - agno = 1
        - agno = 2
        - agno = 3
        - agno = 4 
Phase 5 - rebuild AG headers and trees . . .
        - reset superblock . . .
Phase 6 - check inode connectivity . . .
        - resetting contents of realtime bitmap and summary inodes
        - traversing filesystem . . .
        - traversal finished . . .
        - moving disconnected inodes to lost + found . . .
Phase 7 - verify and correct link counts . . . 
done

你会发现 xfs_repair 命令对文件系统做出了修改让其变得健康。

查看 XFS 版本以及它的详细信息

查看 xfs 文件系统版本很简单。使用 -V 参数运行 xfs_info 再加上挂载点就行了。

root@kerneltalks # xfs_info -V /shrikant
xfs_info version 4.5.0

若要查看 XFS 文件系统的详细信息，比如想计算扩容 XFS 文件系统时要新增多少个块，需要了解块大小，块的个数等信息，则不带任何选项运行 xfs_info 加上挂载点。

root@kerneltalks # xfs_info /shrikant
meta-data=/dev/xvdf              isize=512    agcount=5, agsize=720896 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=0 spinodes=0
data     =                       bsize=4096   blocks=2883840, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
log      =internal               bsize=4096   blocks=2560, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

则会显示 XFS 文件系统的所有详细信息，就跟创建 XFS 文件系统时显示的信息一样。

此外还有一些 XFS 文件系统管理命令可以修改并管理 XFS 的元数据。我们将在另一篇文章中来讲解。

via: https://kerneltalks.com/commands/xfs-file-system-commands-with-examples/

作者：kerneltalks 译者：lujun9972 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

在本文中，我们将看一些 TensorFlow 的例子，并从中感受到在定义 张量 tensor 和使用张量做数学计算方面有多么容易，我还会举些别的机器学习相关的例子。

TensorFlow 是什么?

TensorFlow 是 Google 为了解决复杂的数学计算耗时过久的问题而开发的一个库。

事实上，TensorFlow 能干许多事。比如：

• 求解复杂数学表达式
• 机器学习技术。你往其中输入一组数据样本用以训练，接着给出另一组数据样本基于训练的数据而预测结果。这就是人工智能了！
• 支持 GPU 。你可以使用 GPU（图像处理单元）替代 CPU 以更快的运算。TensorFlow 有两个版本： CPU 版本和 GPU 版本。

开始写例子前，需要了解一些基本知识。

什么是张量？

张量 tensor 是 TensorFlow 使用的主要的数据块，它类似于变量，TensorFlow 使用它来处理数据。张量拥有维度和类型的属性。

维度指张量的行和列数，读到后面你就知道了，我们可以定义一维张量、二维张量和三维张量。

类型指张量元素的数据类型。

定义一维张量

可以这样来定义一个张量：创建一个 NumPy 数组（LCTT 译注：NumPy 系统是 Python 的一种开源数字扩展，包含一个强大的 N 维数组对象 Array，用来存储和处理大型矩阵 ）或者一个 Python 列表 ，然后使用 tf_convert_to_tensor 函数将其转化成张量。

可以像下面这样，使用 NumPy 创建一个数组：

import numpy as np arr = np.array([1, 5.5, 3, 15, 20])
arr = np.array([1, 5.5, 3, 15, 20])

运行结果显示了这个数组的维度和形状。

import numpy as np
arr = np.array([1, 5.5, 3, 15, 20])
print(arr)
print(arr.ndim)
print(arr.shape)
print(arr.dtype)

它和 Python 列表很像，但是在这里，元素之间没有逗号。

现在使用 tf_convert_to_tensor 函数把这个数组转化为张量。

import numpy as np
import tensorflow as tf
arr = np.array([1, 5.5, 3, 15, 20])
tensor = tf.convert_to_tensor(arr,tf.float64)
print(tensor)

这次的运行结果显示了张量具体的含义，但是不会展示出张量元素。

要想看到张量元素，需要像下面这样，运行一个会话：

import numpy as np
import tensorflow as tf
arr = np.array([1, 5.5, 3, 15, 20])
tensor = tf.convert_to_tensor(arr,tf.float64)
sess = tf.Session()
print(sess.run(tensor))
print(sess.run(tensor[1]))

定义二维张量

定义二维张量，其方法和定义一维张量是一样的，但要这样来定义数组：

arr = np.array([(1, 5.5, 3, 15, 20),(10, 20, 30, 40, 50), (60, 70, 80, 90, 100)])

接着转化为张量：

import numpy as np
import tensorflow as tf
arr = np.array([(1, 5.5, 3, 15, 20),(10, 20, 30, 40, 50), (60, 70, 80, 90, 100)])
tensor = tf.convert_to_tensor(arr)
sess = tf.Session()
print(sess.run(tensor))

现在你应该知道怎么定义张量了，那么，怎么在张量之间跑数学运算呢？

在张量上进行数学运算

假设我们有以下两个数组：

arr1 = np.array([(1,2,3),(4,5,6)])
arr2 = np.array([(7,8,9),(10,11,12)])

利用 TenserFlow ，你能做许多数学运算。现在我们需要对这两个数组求和。

使用加法函数来求和：

import numpy as np
import tensorflow as tf
arr1 = np.array([(1,2,3),(4,5,6)])
arr2 = np.array([(7,8,9),(10,11,12)])
arr3 = tf.add(arr1,arr2)
sess = tf.Session()
tensor = sess.run(arr3)
print(tensor)

也可以把数组相乘：

import numpy as np
import tensorflow as tf
arr1 = np.array([(1,2,3),(4,5,6)])
arr2 = np.array([(7,8,9),(10,11,12)])
arr3 = tf.multiply(arr1,arr2)
sess = tf.Session()
tensor = sess.run(arr3)
print(tensor)

现在你知道了吧。

三维张量

我们已经知道了怎么使用一维张量和二维张量，现在，来看一下三维张量吧，不过这次我们不用数字了，而是用一张 RGB 图片。在这张图片上，每一块像素都由 x、y、z 组合表示。

这些组合形成了图片的宽度、高度以及颜色深度。

首先使用 matplotlib 库导入一张图片。如果你的系统中没有 matplotlib ，可以 使用 pip来安装它。

将图片放在 Python 文件的同一目录下，接着使用 matplotlib 导入图片：

import matplotlib.image as img
myfile = "likegeeks.png"
myimage = img.imread(myfile)
print(myimage.ndim)
print(myimage.shape)

从运行结果中，你应该能看到，这张三维图片的宽为 150 、高为 150 、颜色深度为 3 。

你还可以查看这张图片：

import matplotlib.image as img
import matplotlib.pyplot as plot
myfile = "likegeeks.png"
myimage = img.imread(myfile)
plot.imshow(myimage)
plot.show()

真酷！

那怎么使用 TensorFlow 处理图片呢？超级容易。

使用 TensorFlow 生成或裁剪图片

首先，向一个占位符赋值：

myimage = tf.placeholder("int32",[None,None,3])

使用裁剪操作来裁剪图像：

cropped = tf.slice(myimage,[10,0,0],[16,-1,-1])

最后，运行这个会话：

result = sess.run(cropped, feed\_dict={slice: myimage})

然后，你就能看到使用 matplotlib 处理过的图像了。

这是整段代码：

import tensorflow as tf
import matplotlib.image as img
import matplotlib.pyplot as plot
myfile = "likegeeks.png"
myimage = img.imread(myfile)
slice = tf.placeholder("int32",[None,None,3])
cropped = tf.slice(myimage,[10,0,0],[16,-1,-1])
sess = tf.Session()
result = sess.run(cropped, feed_dict={slice: myimage})
plot.imshow(result)
plot.show()

是不是很神奇？

使用 TensorFlow 改变图像

在本例中，我们会使用 TensorFlow 做一下简单的转换。

首先，指定待处理的图像，并初始化 TensorFlow 变量值：

myfile = "likegeeks.png"
myimage = img.imread(myfile)
image = tf.Variable(myimage,name='image')
vars = tf.global_variables_initializer()

然后调用 transpose 函数转换，这个函数用来翻转输入网格的 0 轴和 1 轴。

sess = tf.Session()
flipped = tf.transpose(image, perm=[1,0,2])
sess.run(vars)
result=sess.run(flipped)

接着你就能看到使用 matplotlib 处理过的图像了。

import tensorflow as tf
import matplotlib.image as img
import matplotlib.pyplot as plot
myfile = "likegeeks.png"
myimage = img.imread(myfile)
image = tf.Variable(myimage,name='image')
vars = tf.global_variables_initializer()
sess = tf.Session()
flipped = tf.transpose(image, perm=[1,0,2])
sess.run(vars)
result=sess.run(flipped)
plot.imshow(result)
plot.show()

以上例子都向你表明了使用 TensorFlow 有多么容易。

via: https://www.codementor.io/likegeeks/define-and-use-tensors-using-simple-tensorflow-examples-ggdgwoy4u

作者：LikeGeeks 译者：ghsgz 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

精进你的系统管理能力和 Linux 技能，学习如何设置工具来简化管理多台机器。

你是否想精进你的系统管理能力和 Linux 技能？也许你的本地局域网上跑了一些东西，而你又想让生活更轻松一点--那该怎么办呢？在本文中，我会向你演示如何设置工具来简化管理多台机器。

远程管理工具有很多，SaltStack、Puppet、Chef，以及 Ansible 都是很流行的选择。在本文中，我将重点放在 Ansible 上并会解释它是如何帮到你的，不管你是有 5 台还是 1000 台虚拟机。

让我们从多机（不管这些机器是虚拟的还是物理的）的基本管理开始。我假设你知道要做什么，有基础的 Linux 管理技能（至少要有能找出执行每个任务具体步骤的能力）。我会向你演示如何使用这一工具，而是否使用它由你自己决定。

什么是 Ansible？

Ansible 的网站上将之解释为 “一个超级简单的 IT 自动化引擎，可以自动进行云供给、配置管理、应用部署、服务内部编排，以及其他很多 IT 需求。” 通过在一个集中的位置定义好服务器集合，Ansible 可以在多个服务器上执行相同的任务。

如果你对 Bash 的 for 循环很熟悉，你会发现 Ansible 操作跟这很类似。区别在于 Ansible 是 幕等的 idempotent 。通俗来说就是 Ansible 一般只有在确实会发生改变时才执行所请求的动作。比如，假设你执行一个 Bash 的 for 循环来为多个机器创建用户，像这样子：

for server in serverA serverB serverC; do ssh ${server} "useradd myuser"; done

这会在 serverA、serverB，以及 serverC 上创建 myuser 用户；然而不管这个用户是否存在，每次运行这个 for 循环时都会执行 useradd 命令。一个幕等的系统会首先检查用户是否存在，只有在不存在的情况下才会去创建它。当然，这个例子很简单，但是幕等工具的好处将会随着时间的推移变得越发明显。

Ansible 是如何工作的？

Ansible 会将 Ansible playbooks 转换成通过 SSH 运行的命令，这在管理类 UNIX 环境时有很多优势：

1. 绝大多数类 UNIX 机器默认都开了 SSH。
2. 依赖 SSH 意味着远程主机不需要有代理。
3. 大多数情况下都无需安装额外的软件，Ansible 需要 2.6 或更新版本的 Python。而绝大多数 Linux 发行版默认都安装了这一版本（或者更新版本）的 Python。
4. Ansible 无需主节点。他可以在任何安装有 Ansible 并能通过 SSH 访问的主机上运行。
5. 虽然可以在 cron 中运行 Ansible，但默认情况下，Ansible 只会在你明确要求的情况下运行。

配置 SSH 密钥认证

使用 Ansible 的一种常用方法是配置无需密码的 SSH 密钥登录以方便管理。（可以使用 Ansible Vault 来为密码等敏感信息提供保护，但这不在本文的讨论范围之内）。现在只需要使用下面命令来生成一个 SSH 密钥，如示例 1 所示。

[09:44 user ~]$ ssh-keygen
Generating public/private rsa key pair。
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Created directory '/home/user/.ssh'。
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa。
Your public key has been saved in /home/user/.ssh/id_rsa.pub。
The key fingerprint is:
SHA256:TpMyzf4qGqXmx3aqZijVv7vO9zGnVXsh6dPbXAZ+LUQ user@user-fedora
The key's randomart image is:
+---[RSA 2048]----+
|                 |
|                 |
|              E  |
|       o .   .。|
|   .  + S    o+。|
|  . .o * .  .+ooo|
| . .+o  o o oo+。*|
|。.ooo* o。*  .*+|
| . o+*BO.o+    .o|
+----[SHA256]-----+

示例 1 ：生成一个 SSH 密钥

在示例 1 中，直接按下回车键来接受默认值。任何非特权用户都能生成 SSH 密钥，也能安装到远程系统中任何用户的 SSH 的 authorized_keys 文件中。生成密钥后，还需要将之拷贝到远程主机上去，运行下面命令：

ssh-copy-id root@servera

注意：运行 Ansible 本身无需 root 权限；然而如果你使用非 root 用户，你需要为要执行的任务配置合适的 sudo 权限。

输入 servera 的 root 密码，这条命令会将你的 SSH 密钥安装到远程主机上去。安装好 SSH 密钥后，再通过 SSH 登录远程主机就不再需要输入 root 密码了。

安装 Ansible

只需要在示例 1 中生成 SSH 密钥的那台主机上安装 Ansible。若你使用的是 Fedora，输入下面命令：

sudo dnf install ansible -y

若运行的是 CentOS，你需要为 EPEL 仓库配置额外的包：

sudo yum install epel-release -y

然后再使用 yum 来安装 Ansible：

sudo yum install ansible -y

对于基于 Ubuntu 的系统，可以从 PPA 上安装 Ansible：

sudo apt-get install software-properties-common -y
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible -y

若你使用的是 macOS，那么推荐通过 Python PIP 来安装：

sudo pip install ansible

对于其他发行版，请参见 Ansible 安装文档 。

Ansible Inventory

Ansible 使用一个 INI 风格的文件来追踪要管理的服务器，这种文件被称之为 库存清单 Inventory 。默认情况下该文件位于 /etc/ansible/hosts。本文中，我使用示例 2 中所示的 Ansible 库存清单来对所需的主机进行操作（为了简洁起见已经进行了裁剪）：

[arch]
nextcloud
prometheus
desktop1
desktop2
vm-host15

[fedora]
netflix

[centos]
conan
confluence
7-repo
vm-server1
gitlab

[ubuntu]
trusty-mirror
nwn
kids-tv
media-centre
nas

[satellite]
satellite

[ocp]
lb00
ocp_dns
master01
app01
infra01

示例 2 ： Ansible 主机文件

每个分组由中括号和组名标识（像这样 [group1] )，是应用于一组服务器的任意组名。一台服务器可以存在于多个组中，没有任何问题。在这个案例中，我有根据操作系统进行的分组（arch、ubuntu、centos、fedora），也有根据服务器功能进行的分组（ocp、satellite）。Ansible 主机文件可以处理比这复杂的多的情况。详细内容，请参阅 库存清单文档。

运行命令

将你的 SSH 密钥拷贝到库存清单中所有服务器上后，你就可以开始使用 Ansible 了。Ansible 的一项基本功能就是运行特定命令。语法为：

ansible -a "some command"

例如，假设你想升级所有的 CentOS 服务器，可以运行：

ansible centos -a 'yum update -y'

注意：不是必须要根据服务器操作系统来进行分组的。我下面会提到，Ansible Facts 可以用来收集这一信息；然而，若使用 Facts 的话，则运行特定命令会变得很复杂，因此，如果你在管理异构环境的话，那么为了方便起见，我推荐创建一些根据操作系统来划分的组。

这会遍历 centos 组中的所有服务器并安装所有的更新。一个更加有用的命令应该是 Ansible 的 ping 模块了，可以用来验证服务器是否准备好接受命令了：

ansible all -m ping

这会让 Ansible 尝试通过 SSH 登录库存清单中的所有服务器。在示例 3 中可以看到 ping 命令的部分输出结果。

nwn | SUCCESS => {
    "changed":false，
    "ping":"pong"
}
media-centre | SUCCESS => {
    "changed":false，
    "ping":"pong"
}
nas | SUCCESS => {
    "changed":false，
    "ping":"pong"
}
kids-tv | SUCCESS => {
    "changed":false，
    "ping":"pong"
}
...

示例 3 ：Ansible ping 命令输出

运行指定命令的能力有助于完成快速任务（LCTT 译注：应该指的那种一次性任务），但是如果我想在以后也能以同样的方式运行同样的任务那该怎么办呢？Ansible playbooks 就是用来做这个的。

复杂任务使用 Ansible playbooks

Ansible 剧本 playbook 就是包含 Ansible 指令的 YAML 格式的文件。我这里不打算讲解类似 Roles 和 Templates 这些比较高深的内容。有兴趣的话，请阅读 Ansible 文档。

在前一章节，我推荐你使用 ssh-copy-id 命令来传递你的 SSH 密钥；然而，本文关注于如何以一种一致的、可重复性的方式来完成任务。示例 4 演示了一种以冥等的方式，即使 SSH 密钥已经存在于目标主机上也能保证正确性的实现方法。

---
- hosts:all
  gather_facts:false
  vars:
    ssh_key:'/root/playbooks/files/laptop_ssh_key'
  tasks:
    - name:copy ssh key
      authorized_key:
        key:"{{ lookup('file'，ssh_key) }}"
        user:root

示例 4：Ansible 剧本 “push ssh keys.yaml”

- hosts: 行标识了这个剧本应该在那个主机组上执行。在这个例子中，它会检查库存清单里的所有主机。

gather_facts: 行指明 Ansible 是否去搜索每个主机的详细信息。我稍后会做一次更详细的检查。现在为了节省时间，我们设置 gather_facts 为 false。

vars: 部分，顾名思义，就是用来定义剧本中所用变量的。在示例 4 的这个简短剧本中其实不是必要的，但是按惯例我们还是设置了一个变量。

最后由 tasks: 标注的这个部分，是存放主体指令的地方。每个任务都有一个 -name:。Ansbile 在运行剧本时会显示这个名字。

authorized_key: 是剧本所使用 Ansible 模块的名字。可以通过命令 ansible-doc -a 来查询 Ansible 模块的相关信息； 不过通过网络浏览器查看 文档 可能更方便一些。authorized\_key 模块 有很多很好的例子可以参考。要运行示例 4 中的剧本，只要运行 ansible-playbook 命令就行了：

ansible-playbook push_ssh_keys.yaml

如果是第一次添加 SSH 密钥，SSH 会提示你输入 root 用户的密码。

现在 SSH 密钥已经传输到服务器中去了，可以来做点有趣的事了。

使用 Ansible 收集信息

Ansible 能够收集目标系统的各种信息。如果你的主机数量很多，那它会特别的耗时。按我的经验，每台主机大概要花个 1 到 2 秒钟，甚至更长时间；然而有时收集信息是有好处的。考虑下面这个剧本，它会禁止 root 用户通过密码远程登录系统：

---
- hosts:all
  gather_facts:true
  vars:
  tasks:
    - name:Enabling ssh-key only root access
      lineinfile:
        dest:/etc/ssh/sshd_config
        regexp:'^PermitRootLogin'
        line:'PermitRootLogin without-password'
      notify:
        - restart_sshd
        - restart_ssh

  handlers:
    - name:restart_sshd
      service:
        name:sshd
        state:restarted
        enabled:true
      when:ansible_distribution == 'RedHat'
    - name:restart_ssh
      service:
        name:ssh
        state:restarted
        enabled:true
      when:ansible_distribution == 'Debian'

示例 5：锁定 root 的 SSH 访问

在示例 5 中 sshd_config 文件的修改是有条件 的，只有在找到匹配的发行版的情况下才会执行。在这个案例中，基于 Red Hat 的发行版与基于 Debian 的发行版对 SSH 服务的命名是不一样的，这也是使用条件语句的目的所在。虽然也有其他的方法可以达到相同的效果，但这个例子很好演示了 Ansible 信息的作用。若你想查看 Ansible 默认收集的所有信息，可以在本地运行 setup 模块：

ansible localhost -m setup |less

Ansible 收集的所有信息都能用来做判断，就跟示例 4 中 vars: 部分所演示的一样。所不同的是，Ansible 信息被看成是内置 变量，无需由系统管理员定义。

更近一步

现在可以开始探索 Ansible 并创建自己的基本了。Ansible 是一个富有深度、复杂性和灵活性的工具，只靠一篇文章不可能就把它讲透。希望本文能够激发你的兴趣，鼓励你去探索 Ansible 的功能。在下一篇文章中，我会再聊聊 Copy、systemd、service、apt、yum、virt，以及 user 模块。我们可以在剧本中组合使用这些模块，还可以创建一个简单的 Git 服务器来存储这些所有剧本。

via: https://opensource.com/article/17/7/automate-sysadmin-ansible

作者：Steve Ovens 译者：lujun9972 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

当想要直接通过 Linux 命令行下载文件，马上就能想到两个工具：wget 和 cURL。它们有很多一样的特征，可以很轻易的完成一些相同的任务。

虽然它们有一些相似的特征，但它们并不是完全一样。这两个程序适用与不同的场合，在特定场合下，都拥有各自的特性。

cURL vs wget： 相似之处

wget 和 cURL 都可以下载内容。它们的核心就是这么设计的。它们都可以向互联网发送请求并返回请求项。这可以是文件、图片或者是其他诸如网站的原始 HTML 之类。

这两个程序都可以进行 HTTP POST 请求。这意味着它们都可以向网站发送数据，比如说填充表单什么的。

由于这两者都是命令行工具，它们都被设计成可脚本化。wget 和 cURL 都可以写进你的 Bash 脚本 ，自动与新内容交互，下载所需内容。

wget 的优势

wget 简单直接。这意味着你能享受它超凡的下载速度。wget 是一个独立的程序，无需额外的资源库，更不会做其范畴之外的事情。

wget 是专业的直接下载程序，支持递归下载。同时，它也允许你下载网页中或是 FTP 目录中的任何内容。

wget 拥有智能的默认设置。它规定了很多在常规浏览器里的事物处理方式，比如 cookies 和重定向，这都不需要额外的配置。可以说，wget 简直就是无需说明，开罐即食！

cURL 优势

cURL是一个多功能工具。当然，它可以下载网络内容，但同时它也能做更多别的事情。

cURL 技术支持库是：libcurl。这就意味着你可以基于 cURL 编写整个程序，允许你基于 libcurl 库中编写图形环境的下载程序，访问它所有的功能。

cURL 宽泛的网络协议支持可能是其最大的卖点。cURL 支持访问 HTTP 和 HTTPS 协议，能够处理 FTP 传输。它支持 LDAP 协议，甚至支持 Samba 分享。实际上，你还可以用 cURL 收发邮件。

cURL 也有一些简洁的安全特性。cURL 支持安装许多 SSL/TLS 库，也支持通过网络代理访问，包括 SOCKS。这意味着，你可以越过 Tor 来使用cURL。

cURL 同样支持让数据发送变得更容易的 gzip 压缩技术。

思考总结

那你应该使用 cURL 还是使用 wget？这个比较得看实际用途。如果你想快速下载并且没有担心参数标识的需求，那你应该使用轻便有效的 wget。如果你想做一些更复杂的使用，直觉告诉你，你应该选择 cRUL。

cURL 支持你做很多事情。你可以把 cURL 想象成一个精简的命令行网页浏览器。它支持几乎你能想到的所有协议，可以交互访问几乎所有在线内容。唯一和浏览器不同的是，cURL 不会渲染接收到的相应信息。

via: https://www.maketecheasier.com/curl-vs-wget/

作者：Nick Congleton 译者：CYLeft 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

可能有时候你启动 Linux 时需要或者希望不使用 GUI（图形用户界面），也就是没有 X，而是选择命令行。不管是什么原因，幸运的是，直接启动进入 Linux 命令行非常简单。它需要在其他内核选项之后对引导参数进行简单的更改。此更改将系统引导到指定的运行级别。

​为什么要这样做？

如果你的系统由于无效配置或者显示管理器损坏或任何可能导致 GUI 无法正常启动的情况而无法运行 Xorg，那么启动到命令行将允许你通过登录到终端进行故障排除（假设你知道要怎么做），并能做任何你需要做的东西。引导到命令行也是一个很好的熟悉终端的方式，不然，你也可以为了好玩这么做。

​访问 GRUB 菜单

在启动时，你需要访问 GRUB 启动菜单。如果在每次启动计算机时菜单未设置为显示，那么可能需要在系统启动之前按住 SHIFT 键。在菜单中，需要选择 Linux 发行版条目。高亮显示后该条目，按下 e 编辑引导参数。

较老的 GRUB 版本遵循类似的机制。启动管理器应提供有关如何编辑启动参数的说明。

​​指定运行级别

​会出现一个编辑器，你将看到 GRUB 会解析给内核的选项。移动到以 linux 开头的行（旧的 GRUB 版本可能是 kernel，选择它并按照说明操作）。这指定了要解析给内核的参数。在该行的末尾（可能会出现跨越多行，具体取决于你的终端分辨率），只需指定要引导的运行级别，即 3（多用户模式，纯文本）。

按下 Ctrl-X 或 F10 将使用这些参数启动系统。开机和以前一样。唯一改变的是启动的运行级别。

这是启动后的页面：

运行级别

你可以指定不同的运行级别，默认运行级别是 5 （多用户图形界面）。1 启动到“单用户”模式，它会启动进入 root shell。3 提供了一个多用户命令行系统。

从命令行切换

在某个时候，你可能想要运行显示管理器来再次使用 GUI，最快的方法是运行这个：

$ sudo init 5

就这么简单。就我个人而言，我发现命令行比使用 GUI 工具更令人兴奋和上手。不过，这只是我的个人偏好。

via: http://www.linuxandubuntu.com/home/how-to-boot-into-linux-command-line

作者：LinuxAndUbuntu 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

在命令行工作时，有时您可能想要知道一个文件中的单词数量、字节数、甚至换行数量。如果您正在寻找这样做的工具，您会很高兴地知道，在 Linux 中，存在一个命令行实用程序，它被称为 wc ，它为您完成所有这些工作。在本文中，我们将通过简单易懂的例子来讨论这个工具。

但是在我们开始之前，值得一提的是，本教程中提供的所有示例都在 Ubuntu 16.04 上进行了测试。

Linux wc 命令

wc 命令打印每个输入文件的新行、单词和字节数。以下是该命令行工具的语法:

wc [OPTION]... [FILE]...

以下是 wc 的 man 文档的解释：

为每个文件打印新行、单词和字节数，如果指定多于一个文件，也列出总的行数。单词是由空格分隔的非零长度的字符序列。如果没有指定文件，或当文件为 `-`，则读取标准输入。

下面的 Q&A 样式的示例将会让您更好地了解 wc 命令的基本用法。

注意：在所有示例中我们将使用一个名为 file.txt 的文件作为输入文件。以下是该文件包含的内容：

hi
hello
how are you
thanks.

Q1. 如何打印字节数

使用 -c 命令选项打印字节数.

wc -c file.txt

下面是这个命令在我们的系统上产生的输出：

文件包含 29 个字节。

Q2. 如何打印字符数

要打印字符数，请使用 -m 命令行选项。

wc -m file.txt

下面是这个命令在我们的系统上产生的输出：

文件包含 29 个字符。

Q3. 如何打印换行数

使用 -l 命令选项来打印文件中的新行数：

wc -l file.txt

这里是我们的例子的输出：

Q4. 如何打印单词数

要打印文件中的单词数量，请使用 -w 命令选项。

wc -w file.txt

在我们的例子中命令的输出如下：

这显示文件中有 6 个单词。

Q5. 如何打印最长行的显示宽度或长度

如果您想要打印输入文件中最长行的长度，请使用 -l 命令行选项。

wc -L file.txt

下面是在我们的案例中命令产生的结果：

所以文件中最长的行长度是 11。

Q6. 如何从文件读取输入文件名

如果您有多个文件名，并且您希望 wc 从一个文件中读取它们，那么使用-files0-from 选项。

wc --files0-from=names.txt

如你所见 wc 命令，在这个例子中，输出了文件 file.txt 的行、单词和字符计数。文件名为 file.txt 的文件在 name.txt 文件中提及。值得一提的是，要成功地使用这个选项，文件中的文件名应该用 NUL 终止——您可以通过键入Ctrl + v 然后按 Ctrl + Shift + @ 来生成这个字符。

结论

正如您所认同的一样，从理解和使用目的来看， wc 是一个简单的命令。我们已经介绍了几乎所有的命令行选项，所以一旦你练习了我们这里介绍的内容，您就可以随时在日常工作中使用该工具了。想了解更多关于 wc 的信息，请参考它的 man 文档。

via: https://www.howtoforge.com/linux-wc-command-explained-for-beginners-6-examples/

作者：Himanshu Arora 译者：stevenzdg988 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出