RHEL8_Linux_Ansible常用模块的使用

2023-12-18 16:29:38

本章主要介绍Ansible中最常见模块的使用

shell模块
文件管理模块
软件包管理模块
服务管理模块
磁盘管理模块
用户管理模块
防火墙管理模块

ansible的基本用法如下。

ansible 机器名 -m 模块x -a "模块的参数"

对被管理机器执行不同的操作，只需要调用不同的模块就可以了。

ansible中内置了很多的模块,可以通过ansible-doc -l查看系统中所有的模块。

[blab@node01 ~]$ ansible-doc -l
a10_server                                                    Manage A10 Ne.>
a10_server_axapi3                                             Manage A10 Ne.>
a10_service_group                                             Manage A10 Ne.>

按【Enter】键会一行一行地往下显示，按空格键会一页一页地往下显示，按【q】键退出。

不同的模块有不同的参数，如果要查看某个模块的参数，可以通过如下语法来查看。

ansible-doc 模块名

????????ansible中有很多模块，每个模块也有很多参数，我们是不可能把所有的模块、每个模块的所有参数都掌握的。所以，下面我们只讲解最常见的模块及这些模块中最常见的参数的使用方法。

1.shell模块

shell模块可以在远端执行操作系统命令，具体用法如下

ansible 主机组 -m shell -a "系统命令"

1）在node02上执行hostname命令，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "hostname"
node02 | CHANGED | rc=0 >>
node02
[blab@node01 ~]$

????????这里rc=0的意思是执行此命令之后的返回值为0，rc的意思是returm code(返回值)，为0说明正确执行了,非零说明没有正确执行。

2）在 node02上执行一个错误的命令，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "hostnamexxx"
node02 | FAILED | rc=127 >>
/bin/sh: hostnamexxx: 未找到命令non-zero return code
[blab@node01 ~]$

这里rc=127的意思是执行此命令之后的返回值为127，非零说明没有正确执行。

2.文件管理的file模块

file模块用于创建和删除文件/目录，修改文件/目录属性，其常见的参数包括以下几个：

path：用于指定文件/目录的路径，此选项可以用name或dest替代。
state：指定行为。
touch：创建文件。
directory：创建目录。
file：对已存文件进行修改。
absent：删除。
link：软链接。
hard：硬链接。
其他参数:owner指定所有者，group指定所属组，mode指定权限，setype指定上下文。

1）在node02上创建一个文件/opt/hosts，并设置所有者为root，所属组为tom，权限为444，命令如下。

[blab@node01 ~]$ ansible node02 -m file -a "path=/opt/hosts owner=root group=tom mode=444 state=touch"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "dest": "/opt/hosts",
    "gid": 1002,
    "group": "tom",
    "mode": "0444",
    "owner": "root",
    "secontext": "unconfined_u:object_r:usr_t:s0",
    "size": 0,
    "state": "file",
    "uid": 0
}
[blab@node01 ~]$

需要注意的是，此处用path指定的文件，替换成name也是可以的，即name=/opt/hosts。

查看文件的属性,命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "ls -l /opt/hosts"
node02 | CHANGED | rc=0 >>
-r--r--r--. 1 root tom 0 12月 15 11:53 /opt/hosts
[blab@node01 ~]$

2）为/opt/hosts创建一个软链接/opt/hosts123，命令如下。

[blab@node01 ~]$ ansible node02 -m file -a "src=/opt/hosts dest=/opt/hosts123 state=link"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "dest": "/opt/hosts123",
    "gid": 0,
    "group": "root",
    "mode": "0777",
    "owner": "root",
    "secontext": "unconfined_u:object_r:usr_t:s0",
    "size": 10,
    "src": "/opt/hosts",
    "state": "link",
    "uid": 0
}
[blab@node01 ~]$

验证，命令如下

[blab@node01 ~]$ ansible node02 -m shell -a "ls -l /opt"
node02 | CHANGED | rc=0 >>
总用量 0
-r--r--r--. 1 root tom   0 12月 15 11:53 hosts
lrwxrwxrwx. 1 root root 10 12月 15 11:54 hosts123 -> /opt/hosts
[blab@node01 ~]$

3）删除/opt/hosts123，命令如下

[blab@node01 ~]$ ansible node02 -m file -a "name=/opt/hosts123 state=absent"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "path": "/opt/hosts123",
    "state": "absent"
}
[blab@node01 ~]$

4）创建目录/op/xx，上下文设置为default_t，命令如下。

[blab@node01 ~]$ ansible node02 -m file -a "name=/opt/xx state=directory setype=default_t"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "gid": 0,
    "group": "root",
    "mode": "0755",
    "owner": "root",
    "path": "/opt/xx",
    "secontext": "unconfined_u:object_r:default_t:s0",
    "size": 6,
    "state": "directory",
    "uid": 0
}
[blab@node01 ~]$

验证

[blab@node01 ~]$ ansible node02 -m shell -a "ls -dZ /opt/xx"
node02 | CHANGED | rc=0 >>
unconfined_u:object_r:default_t:s0 /opt/xx
[blab@node01 ~]$

5）把/opt/hosts的权限改成000，所有者改成tom，所属组改成users，

[blab@node01 ~]$ ansible node02 -m file -a "name=/opt/hosts owner=tom group=users mode=000"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "gid": 100,
    "group": "users",
    "mode": "0000",
    "owner": "tom",
    "path": "/opt/hosts",
    "secontext": "unconfined_u:object_r:usr_t:s0",
    "size": 0,
    "state": "file",
    "uid": 1002
}
[blab@node01 ~]$

验证

[blab@node01 ~]$ ansible node02 -m shell -a "ls -l /opt/hosts"
node02 | CHANGED | rc=0 >>
----------. 1 tom users 0 12月 15 11:53 /opt/hosts
[blab@node01 ~]$

注意：指定文件使用name或path都是可以的

6）清空node02 上/opt中所有的内容，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "rm -rf /opt/*"
[WARNING]: Consider using the file module with state=absent rather than running
'rm'.  If you need to use command because file is insufficient you can add
'warn: false' to this command task or set 'command_warnings=False' in
ansible.cfg to get rid of this message.
node02 | CHANGED | rc=0 >>

[blab@node01 ~]$

????????上面的WARNING可以忽略不管，如果不想显示此消息，则在ansible.cfg的[defaults]字段下添加 command warnings=False即可。

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "ls /opt/"
node02 | CHANGED | rc=0 >>

[blab@node01 ~]$

3.copy和fetch模块

copy用于把本地的文件拷贝到被管理机器，语法如下。

ansible 主机组 -m copy -a "src=/path1/file1 dest=path2/"

作用是把本地的/path1/file1拷贝到目的主机的/path2中。

copy模块常见的参数包括以下几个:

src：源文件
dest：目的地，即拷贝到哪里
owner：所有者
group：所属组
mode：权限

1.copy模块

1）把本地的文件/etc/ansible/hosts拷贝到目标机器的/opt目录中，并设置权限为000,所有者为tom,命令如下。

[blab@node01 ~]$ ansible node02 -m copy -a "src=/etc/ansible/hosts mode=000 owner=tom dest=/opt"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "checksum": "da996f1a52dbae3b6b43a6c50d761e4ed5ec9a9f",
    "dest": "/opt/hosts",
    "gid": 0,
    "group": "root",
    "md5sum": "1564b951dc7c8511c6f9ee842653c541",
    "mode": "0000",
    "owner": "tom",
    "secontext": "system_u:object_r:usr_t:s0",
    "size": 1016,
    "src": "/home/blab/.ansible/tmp/ansible-tmp-1702614292.969332-5748-241468010987805/source",
    "state": "file",
    "uid": 1002
}
[blab@node01 ~]$

验证

[blab@node01 ~]$ ansible node02 -m shell -a "ls -l /opt/hosts"
node02 | CHANGED | rc=0 >>
----------. 1 tom root 1016 12月 15 12:24 /opt/hosts
[blab@node01 ~]$

copy模块也可以利用content参数往某个文件中写内容，如果此文件不存在则会创建出来。

2）在被管理机器的/opt目录中创建11.txt，内容为123123，命令如下。

[blab@node01 ~]$ ansible node02 -m copy -a 'content="123123" dest=/opt/11.txt '
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "checksum": "601f1889667efaebb33b8c12572835da3f027f78",
    "dest": "/opt/11.txt",
    "gid": 0,
    "group": "root",
    "md5sum": "4297f44b13955235245b2497399d7a93",
    "mode": "0644",
    "owner": "root",
    "secontext": "system_u:object_r:usr_t:s0",
    "size": 6,
    "src": "/home/blab/.ansible/tmp/ansible-tmp-1702614452.0289679-5825-32381171106061/source",
    "state": "file",
    "uid": 0
}
[blab@node01 ~]$

验证/opt/11.txt的内容

[blab@node01 ~]$ ansible node02 -m shell -a "cat /opt/11.txt"
node02 | CHANGED | rc=0 >>
123123
[blab@node01 ~]$

2.fetch模块

1）fetch用于把文件从被管理机器拷贝到本机当前目录中,命令如下。

[blab@node01 ~]$ ansible node02 -m fetch -a "src=/opt/hosts dest=./"
node02 | CHANGED => {
    "changed": true,
    "checksum": "da996f1a52dbae3b6b43a6c50d761e4ed5ec9a9f",
    "dest": "/home/blab/node02/opt/hosts",
    "md5sum": "1564b951dc7c8511c6f9ee842653c541",
    "remote_checksum": "da996f1a52dbae3b6b43a6c50d761e4ed5ec9a9f",
    "remote_md5sum": null
}
[blab@node01 ~]$

2）查看

[blab@node01 ~]$ tree node02
node02
└── opt
    └── hosts

1 directory, 1 file
[blab@node01 ~]$

4.yum_repository模块

利用yum_repository设置yum 源，一个标准的repo配置文件如下所示。

[root@node01 ~]# cat /etc/yum.repos.d/aa.repo 
[aa]
name=aa
baseurl=file:///mnt/AppStream
enabled=1
gpgcheck=0

[bb]
name=bb
baseurl=///mnt/BaseOS
enabled=1
gpgcheck=0
[root@node01 ~]#

其中文中的名称用于区分不同的yum 源。这里参数的含义如下。

name：此 yum 源的描述信息
baseurl：用于指定yum源的具体地址‘
enabled：用于指定是否启用次yum源
gpgcheck：用于指定在安装软件包是，是否要进行数字签名的验证，一般设置为0即可
gpgkey：在gpgcheck设置为1的情况下，用于指定公钥的位置对于yum_repository模块来说，常见的参数包括以下几个：

????????（1）name：repo配置文件里 [] 中的名称。

????????（2）description：repo配置文件里name字段的描述信息。

????????（3）baseurl :用于指定yum源的位置。

????????（4）enabled :是否启用源，值为true 或false。

????????（5）gpgcheck:是否启用数字签名验证，值为true或falsc。(6） gpgkey:用于指定公钥的位置。

1）给node02配置yum源，地址是ftp://192.168.182.200/dvd/AppStream，所需要的密钥文件为ftp://192.168.8.11/dvd/RPM-GPG-KEY-redhat-release，命令如下。

[blab@node01 ~]$ ansible node02 -m yum_repository -a "name=app description='this is appstream' baseurl=ftp://192.168.182.200/dvd/AppStream gpgcheck=yes gpgkey=ftp://192.168.182.200/dvd/RPM-GPG-KEY-redhat-release"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "repo": "app",
    "state": "present"
}
[blab@node01 ~]$

执行之后的效果如下

[blab@node01 ~]$ ansible node02 -m shell -a "ls /etc/yum.repos.d"
node02 | CHANGED | rc=0 >>
aa.repo
app.repo
redhat.repo
[blab@node01 ~]$ 
[blab@node01 ~]$ ansible node02 -m shell -a "cat /etc/yum.repos.d/app.repo"
node02 | CHANGED | rc=0 >>
[app]
baseurl = ftp://192.168.182.200/dvd/AppStream
gpgcheck = 1
gpgkey = ftp://192.168.182.200/dvd/RPM-GPG-KEY-redhat-release
name = this is appstream
[blab@node01 ~]$

????????给node02配置第二个yum源，地址是 ftp://192.168.182.200/dvd/BaseOS，所需要的密钥文件为fip://192.168.182.200/dvd/RPM-GPG-KEY-redhat-release，命令如下。

[blab@node01 ~]$ ansible node02 -m yum_repository -a "name=baseos description='this is baseos' baseurl=ftp://192.168.182.200/dvd/BaseOS gpgcheck=yes gpgkey=ftp://192.168.182.200/dvd/RPM-GPG-KEY-redhat-release"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "repo": "baseos",
    "state": "present"
}
[blab@node01 ~]$

1.使用yum模块管理软件包

yum模块常见的参数包括以下几个：

name：用于指定软件包的名称
state：此参数的值如下：

? ? ? ?①present或installed：用于安装软件包，没有指定state时的默认值就是installed。

????????②absent或removed：用于卸载软件包。

????????③latest：用于更新。

注意：yum模块可以用package模块替代，用于在 Ubuntu等其他系统上管理软件包。

练习1：在node02上安装vsftpd，命令如下。

[blab@node01 ~]$ ansible node02 -m yum -a "name=vsftpd state=installed"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "",
    "rc": 0,
    "results": [
        "Installed: vsftpd-3.0.3-34.el8.x86_64"
    ]
}
[blab@node01 ~]$

验证，

[blab@node01 ~]$ ansible node02 -m shell -a "rpm -qa | grep vsftpd"
[WARNING]: Consider using the yum, dnf or zypper module rather than running
'rpm'.  If you need to use command because yum, dnf or zypper is insufficient
you can add 'warn: false' to this command task or set 'command_warnings=False'
in ansible.cfg to get rid of this message.
node02 | CHANGED | rc=0 >>
vsftpd-3.0.3-34.el8.x86_64
[blab@node01 ~]$

练习2：在server2上卸载vsftpd，命令如下。

[blab@node01 ~]$ ansible node02 -m yum -a "name=vsftpd state=absent"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "",
    "rc": 0,
    "results": [
        "Removed: vsftpd-3.0.3-34.el8.x86_64"
    ]
}
[blab@node01 ~]$

如果本机没有安装vsftpd，下面的命令就是安装，如果已经安装则更新到最新版。

[blab@node01 ~]$ ansible node02 -m yum -a "name=vsftpd state=latest"

如果要安装组或模块，需要在组名或模块名前加@，这个模块要使用引号引起来。

练习3：安装 RPM开发工具,命令如下。

[blab@node01 ~]$ ansible node02 -m yum -a "name='@开发工具' state=installed"
node02 | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": false,
    "msg": "Nothing to do",
    "rc": 0,
    "results": [
        "Group development installed."
    ]
}
[blab@node01 ~]$

5.使用service 模块管理任务

????????可以通过systemctl对服务进行启动、重启、关闭等操作，在ansible中可以调用service模块来实现对服务的管理，service模块常见的参数包括以下几个。

name：指定对哪个服务进行管理
enabled：用于设置此服务是否开机自动启动，值为yes或no，默认值为空
state：用于启动或关闭服务，其值包括started，stopped，restarted等

首先判断node02上的vsftpd是否启动，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "systemctl is-active vsftpd"
node02 | FAILED | rc=3 >>
inactivenon-zero return code
[blab@node01 ~]$

这里返回值为3(rc=3)，说明node02上的vsftpd没有启动。

练习1：启动vsftpd并设置开机自动启动，命令如下。

[blab@node01 ~]$ ansible node02 -m service -a "name=vsftpd state=started enabled=yes"

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "systemctl is-active vsftpd"
node02 | CHANGED | rc=0 >>
active
[blab@node01 ~]$

或者到 node02上验证,命令如下

[root@node02 ~]# systemctl is-active vsftpd
active
[root@node02 ~]#

6.使用parted模块对硬盘分区

在 ansible中如果对分区进行管理，使用的是parted模块，parted模块常见的参数包括以下几个。

device：指定是哪块磁盘
number：第几个分区
part_start：指的是从硬盘的什么位置开始划分，不写默认为从头开始（0%）
part_end：指的是到硬盘的什么位置作为分区的结束点
state：用于指定操作，present是创建，absent是删除

自行在node02上新添加一块类型为SCSI、大小为20G的硬盘，命令如下。

练习1：在server2上对/devIsdb创建一个大小为2GiB的分区/dev/sdb1，命令如下。

[blab@node01 ~]$ ansible node02 -m parted -a "device=/dev/sda number=1 part_end=2GiB state=present"

????????此例是对/dev/sdb创建第一个分区，因为从硬盘头开始，所以不需要指定part_start，此分区到2GB位置结束。

[blab@node01 ~]$ ansible node02 -m shell -a "lsblk"
node02 | CHANGED | rc=0 >>
NAME          MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda             8:0    0   20G  0 disk 
└─sda1          8:1    0    2G  0 part         //可以看到添加成功
sr0            11:0    1 10.2G  0 rom  
nvme0n1       259:0    0   30G  0 disk 
├─nvme0n1p1   259:1    0    1G  0 part /boot
└─nvme0n1p2   259:2    0   29G  0 part 
  ├─rhel-root 253:0    0   26G  0 lvm  /
  └─rhel-swap 253:1    0    3G  0 lvm  [SWAP]
[blab@node01 ~]$

练习2：在server2上对/dev/sdb创建一个大小为2GB的分区/dev/sdb2，命令如下。

[blab@node01 ~]$ ansible node02 -m parted -a "device=/dev/sda number=2 part_start=2GiB part_end=4GiB state=present"

此例是对/dev/sdb创建第二个分区，从2GiB位置开始，到4GiB位置结束。

在node02上查看分区，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "lsblk"
node02 | CHANGED | rc=0 >>
NAME          MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda             8:0    0   20G  0 disk 
├─sda1          8:1    0    2G  0 part 
└─sda2          8:2    0    2G  0 part     //可以看到第二个已经创建成功
sr0            11:0    1 10.2G  0 rom  
nvme0n1       259:0    0   30G  0 disk 
├─nvme0n1p1   259:1    0    1G  0 part /boot
└─nvme0n1p2   259:2    0   29G  0 part 
  ├─rhel-root 253:0    0   26G  0 lvm  /
  └─rhel-swap 253:1    0    3G  0 lvm  [SWAP]
[blab@node01 ~]$

练习3：删除node02上的/dev/sda2，命令如下。

[blab@node01 ~]$ ansible node02 -m parted -a "device=/dev/sda number=2 state=absent"

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "lsblk"
node02 | CHANGED | rc=0 >>
NAME          MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda             8:0    0   20G  0 disk 
└─sda1          8:1    0    2G  0 part 
sr0            11:0    1 10.2G  0 rom  
nvme0n1       259:0    0   30G  0 disk 
├─nvme0n1p1   259:1    0    1G  0 part /boot
└─nvme0n1p2   259:2    0   29G  0 part 
  ├─rhel-root 253:0    0   26G  0 lvm  /
  └─rhel-swap 253:1    0    3G  0 lvm  [SWAP]
[blab@node01 ~]$

可以看到，/dev/sda2已经被删除了。

请自行创建出/dev/sda2和/dev/sda3备用，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "lsblk"
node02 | CHANGED | rc=0 >>
NAME          MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda             8:0    0   20G  0 disk 
├─sda1          8:1    0    2G  0 part 
├─sda2          8:2    0    2G  0 part 
└─sda3          8:3    0    2G  0 part

7.使用filesystem模块格式化

????????分区创建好之后，需要对分区进行格式化操作，格式化的模块为filesystem，filesystem 模块常见的参数包括以下几个：

（1）dev：用于指定对哪个设备进行格式化。

（2）fstype：用于指定用什么文件系统进行格式化。

（3）force：是否强制格式化，默认为no。

练习1：把 node02上的/dev/sda3格式化为XFS文件系统，命令如下。

[blab@node01 ~]$ ansible node02 -m filesystem -a "dev=/dev/sda3 fstype=xfs"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true
}
[blab@node01 ~]$

如果想重新格式化，需要加上 force选项，命令如下。

[blab@node01 ~]$ ansible node02 -m filesystem -a "dev=/dev/sda3 fstype=xfs force=yes"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true
}
[blab@node01 ~]$

8.使用mount 模块挂载文件系统

格式化之后就需要挂载分区，挂载用的是mount模块，mount模块常见的参数包括以下几个：

src：用于指定挂载哪个设备
path：用于指定挂载点
fstype：用于指定挂载问年间系统，这个选项一定要指定
opts：用于指定挂载选项，如果不指定则为default
state：此参数的值如下：

①mounted：挂载的同时，也会写入/etc/fstab。

②present：只是写入/etc/fstab，但当前并没有挂载。

③unmounted：只卸载，并不会把条目从/etc/fstab中删除。

④absent：卸载并从/etc/fstab中删除。

练习1：把node02上的/dev/sda3挂载到/123目录上，挂载选项为只读，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a "mkdir /123"
[blab@node01 ~]$ ansible node02 -m mount -a "src=/dev/sda3 path=/123 state=mounted fstype=xfs opts=defaults,ro"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "dump": "0",
    "fstab": "/etc/fstab",
    "fstype": "xfs",
    "name": "/123",
    "opts": "defaults,ro",
    "passno": "0",
    "src": "/dev/sda3"
}
[blab@node01 ~]$

这里指定了挂载选项为defaults,ro，多个选项用逗号隔开。

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "df -Th | grep sda3"
node02 | CHANGED | rc=0 >>
/dev/sda3             xfs       2.0G  256K  2.0G    1% /123
[blab@node01 ~]$

因为挂载时state的值是mounted，所以不仅把/dev/sda3挂载了，也写人/etc/fstab了。

练习2：在node02上卸载并从/etc/fstab中删除/dev/sda3，命令如下。

[blab@node01 ~]$ ansible node02 -m mount -a "src=/dev/sda3 path=/123 state=absent"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "dump": "0",
    "fstab": "/etc/fstab",
    "name": "/123",
    "opts": "defaults",
    "passno": "0",
    "src": "/dev/sda3"
}
[blab@node01 ~]$

注意：如果卸载，path是一定要指定的，src指定不指定都无所谓。

9.使用lvg模块对卷组进行管理

使用lvg模块管理卷组，此模块常见的参数包括以下几个：

pvs：用于指定物理卷，如果有多个PV则用逗号隔开，不需要提前创建PV，此命令会自动创建PV
vg：用以指定卷组的名称
pesize：用于指定PE的大小
state：此参数的值如下：present :用于创建卷组，默认。absent :用于删除卷组。

练习1：在node02上创建名称为vg0的卷组，所使用的分区为/dev/sda1和/dev/sda2/pesize指定为16M。

1）先确认node02上不存在任何PV 和VG,命令如下这里之前实验存在一个不用管。

[blab@node01 ~]$ ansible node02 -m shell -a "vgs"
node02 | CHANGED | rc=0 >>
  VG   #PV #LV #SN Attr   VSize   VFree
  rhel   1   2   0 wz--n- <29.00g    0 
[blab@node01 ~]$

2）开始创建vg0，命令如下

[blab@node01 ~]$ ansible node02 -m lvg -a "pvs=/dev/sda1,/dev/sda2 vg=vg0 pesize=16 state=present"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true
}
[blab@node01 ~]$

这里如果不指定pesize选项，则默认为4。

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "vgs"
node02 | CHANGED | rc=0 >>
  VG   #PV #LV #SN Attr   VSize   VFree 
  rhel   1   2   0 wz--n- <29.00g     0 
  vg0    2   0   0 wz--n-  <3.97g <3.97g
[blab@node01 ~]$

练习2：删除卷组 vg0，命令如下。

[blab@node01 ~]$ ansible node02 -m lvg -a "vg=vg0 pesize=16 state=absent"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true
}
[blab@node01 ~]$

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "vgs"
node02 | CHANGED | rc=0 >>
  VG   #PV #LV #SN Attr   VSize   VFree
  rhel   1   2   0 wz--n- <29.00g    0 
[blab@node01 ~]$

可以看到，vg0已经没有了。

请使用ansible node02 -m lvg -a "pvs=ldev/sda1,/dev/sda2 vg-vg0 pesize=16

state-present"命令再次把vg0创建出来。

10.使用lvol模块管理逻辑卷

卷组创建好之后就要创建逻辑卷了，管理逻辑卷的模块是Ivol，lvol模块常见的参数包含以下几个：

vg：用于指定在哪个卷组上划分逻辑卷
lv：用于指定逻辑卷的名称
size：用于指定逻辑卷的大小
state：此参数的值如下：present :用于创建逻辑卷。absent :用于删除逻辑卷。

练习1：在node02的卷组 vg0上，创建大小为1G、名称为lv0的逻辑卷。

1）先判断node02上是否存在逻辑卷，命令如下。

[blab@node01 ~]$ ansible node02 -m shell -a 'lvs'
node02 | CHANGED | rc=0 >>
                                                   
[blab@node01 ~]$

2）可以看到，不存在任何逻辑卷。下面开始创建逻辑卷，命令如下。

[blab@node01 ~]$ ansible node02 -m lvol -a "vg=vg0 lv=lv0 size=1G"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": ""
}
[blab@node01 ~]$

3）验证：

[blab@node01 ~]$ ansible node02 -m shell -a "lvs"
node02 | CHANGED | rc=0 >>
  LV   VG   Attr       LSize   Pool Origin Data%  Meta%  Move Log Cpy%Sync Convert                                                
  lv0  vg0  -wi-a-----   1.00g                                                    
[blab@node01 ~]$

可以看到,此逻辑卷已经创建出来了。

练习2：在node2上删除逻辑卷/dev/vg0/lv0，命令如下。

[blab@node01 ~]$ ansible node02 -m lvol -a "vg=vg0 lv=lv0 state=absent force=yes"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true
}
[blab@node01 ~]$

11.使用firewalld模块管理防火墙

在ansible中可以通过firewalld模块对防火墙进行管理，firewalld模块常见的参数包括以下几个：

service：开放某个服务
port：开放某个端口，用法为port=80/tcp
permanent=yes：设置永久生效，不存在默认值
immediate=yes：设置当前生效，默认为不生效
state：此参数如下：
①enabled：用于创建规则。

②disabled：用于删除规则。
rich_rule：富规则

练习1：在node2上开放服务http，命令如下。

[blab@node01 ~]$ ansible node02 -m firewalld -a "service=http immediate=yes permanent=yes state=enabled"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "Permanent and Non-Permanent(immediate) operation, Changed service http to enabled"
}
[blab@node01 ~]$

2）验证

[blab@node01 ~]$ ansible node02 -m shell -a "firewall-cmd --list-all"
node02 | CHANGED | rc=0 >>
public (active)
  target: default
  icmp-block-inversion: no
  interfaces: ens160
  sources: 
  services: cockpit dhcpv6-client http ssh    //可以看到已经添加http服务
  ports: 
  protocols: 
  forward: no
  masquerade: no
  forward-ports: 
  source-ports: 
  icmp-blocks: 
  rich rules: 
[blab@node01 ~]$

练习2：在node02上配置防火墙,允许tcp端口808通过，命令如下。

[blab@node01 ~]$ ansible node02 -m firewalld -a"port=808/tcp immediate=yes permanent=yes state=enabled"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "Permanent and Non-Permanent(immediate) operation, Changed port 808/tcp to enabled"
}
[blab@node01 ~]$

验证：

[blab@node01 ~]$ ansible node02 -m shell -a "firewall-cmd --list-all"
node02 | CHANGED | rc=0 >>
public (active)
  target: default
  icmp-block-inversion: no
  interfaces: ens160
  sources: 
  services: cockpit dhcpv6-client http ssh
  ports: 808/tcp    //可以看到端口已经添加
  protocols: 
  forward: no
  masquerade: no
  forward-ports: 
  source-ports: 
  icmp-blocks: 
  rich rules: 
[blab@node01 ~]$

练习3：在node02上配置防火墙，删除开放的端口808和服务http，命令如下。

[blab@node01 ~]$ ansible node02 -m firewalld -a "port=808/tcp immediate=yes permanent=yes state=disabled"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "Permanent and Non-Permanent(immediate) operation, Changed port 808/tcp to disabled"
}
[blab@node01 ~]$

12.替换模块replace

????????平时写shell脚本时，要替换文件的内容，可以直接使用vim或sed命令来进行替换操作。在 ansible中也有相关的替换模块:replace和 lineinfile，这里先讲replace模块的使用。

replace模块常见的参数包括以下几个：

path：指明编辑的文件
regexp：正则表达式，指定要替换的字符
replace：替换后的字符

练习1：把node02 上 /opt/aa.txt中开头为aa那行的内容替换为xx=666。

1）在node02的lopt目录中创建aa.txt，内容如下。

[root@node02 ~]# cat /opt/aa.txt 
aa=111
bb=222
[root@node02 ~]#

2）在ansible主机上执行replace模块，命令如下。

[blab@node01 ~]$ ansible node02 -m replace -a "path=/opt/aa.txt regexp=aa=111 replace=xx=666"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "1 replacements made"
}
[blab@node01 ~]$

????????这里的意思是把node02 上/opt/aa.txt这个文件中aa=111的字符替换成xx=666。记住,这里只是对regexp表示的字符进行替换，替换之后的内容如下。

[blab@node01 ~]$ ansible node02 -m shell -a "cat /opt/aa.txt"
node02 | CHANGED | rc=0 >>
xx=666
bb=222
[blab@node01 ~]$

????????可以看到,只是把原来的字符aa替换成replace后面的内容了，并不是把这行内容替换掉。如果想把整行内容进行替换，需要在regexp后面表示出来整行内容。

练习2：把 node02上 /opt/aa.txt中开头为bb那行的内容替换为xx=666，命令如下。

[blab@node01 ~]$ ansible node02 -m replace -a "path=/opt/aa.txt regexp=^bb.+ replace=xx=666"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "msg": "1 replacements made"
}
[blab@node01 ~]$

????????这里path指明了要替换的文件，regexp的写法是^bb.+，比上面的例子中多了.+，意思是开头是bb及后续所有的字符（这就表示以bb开头的那一整行内容)，替换成xx=666，运行结果如下。

[blab@node01 ~]$ ansible node02 -m shell -a "cat /opt/aa.txt"
node02 | CHANGED | rc=0 >>
xx=666
xx=666
[blab@node01 ~]$

13.替换模块lineinfile

lineinfile模块的用法与replace基本一致，也是用于替换的，常见的参数包括以下几个：

（1）path：指明编辑的文件。

（2）regexp：正则表达式。

（3）line：替换后的字符。

练习1：把node02 上/opt/bb.txt中开头为aa=111那行的内容替换为xx=666。

1）在node02上创建文件/opt/bb.txt，内容如下。

[root@node02 ~]# cat /opt/bb.txt 
aa=111
bb=222
[root@node02 ~]#

2）在ansible主机上执行lineinfile模块,命令如下。

[blab@node01 ~]$ ansible node02 -m lineinfile -a "path=/opt/bb.txt regexp=^aa line=xx=666"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "backup": "",
    "changed": true,
    "msg": "line replaced"
}
[blab@node01 ~]$

????????这里的意思是把path所指定的文件/opt/bb.txt，regexp后面跟的^aa，即以aa开头的行 (需要注意的是，这里和 replace模块有区别)，替换成xx=666，运行结果如下。

[blab@node01 ~]$ ansible node02 -m shell -a "cat /opt/bb.txt"
node02 | CHANGED | rc=0 >>
xx=666
bb=222
[blab@node01 ~]$

????????总结：replace是对字符进行替换，lineinfile是对行进行替换，如果replace想对行进行替换,在regexp后面必须写上正则表达式来表示一整行内容。

14.打印模块debug

????????debug模块一般用于打印提示信息，类似于shell 中的echo命令，其他语言如Python等中的print，其常见的参数包括以下几个：

msg：后面跟具体内容
var：后面跟变量

注意：var 和 msg 不可以同时使用

练习：在server2上打印“111”，命令如下。

[blab@node01 ~]$ ansible node02 -m debug -a "msg='hello luo'"
node02 | SUCCESS => {
    "msg": "hello luo"
}
[blab@node01 ~]$

15.使用script模块在远端执行脚本

????????如果在本地写了一个脚本，想在所有被管理节点上执行，没有必要事先把脚本分发到被管理机器上，使用script模块即可快速实现。

1）先写一个简单的脚本test1.sh 用于显示主机名，内容如下。

[blab@node01 ~]$ cat test1.sh 
#!/bin/bash
hostname
[blab@node01 ~]$ chmod +x test1.sh 
[blab@node01 ~]$

2）下面在db1主机组上执行，命令如下。

[blab@node01 ~]$ ansible db1 -m script -a "./test1.sh"
node02 | CHANGED => {
    "changed": true,
    "rc": 0,
    "stderr": "Shared connection to node02 closed.\r\n",
    "stderr_lines": [
        "Shared connection to node02 closed."
    ],
    "stdout": "node02\r\n",
    "stdout_lines": [
        "node02"
    ]
}

这样本地脚本直接在所有被管理主机上执行了。

16.使用group模块对组进行管理

如果对系统的组进行管理，那么可以使用group模块。group模块常见的参数包括以下几个：

name：指定组名
state：此三处的值如下
①present：用于创建组。

②absent：用于删除组。

下面在node02上创建组 group1。

1）先判断node02上是否存在group1，命令如下。

[root@node02 ~]# grep group1 /etc/group
[root@node02 ~]#

2）没有任何输出，说明node02上是没有group1这个组的。下面创建组group1，命令如下。

[blab@node01 ~]$ ansible node02 -m group -a "name=group1 state=present"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "gid": 1003,
    "name": "group1",
    "state": "present",
    "system": false
}
[blab@node01 ~]$

3）然后切换到node02上进行验证，命令如下。

[root@node02 ~]# grep group1 /etc/group
group1:x:1003:
[root@node02 ~]#

4）删除这个组，命令如下。

[blab@node01 ~]$ ansible node02 -m group -a "name=group1 state=absent"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "name": "group1",
    "state": "absent"
}
[blab@node01 ~]$

17.使用user模块对用户进行管理

对用户的管理可以使用user模块，对于user模块来说，常见的参数包括以下几个：

name：指定用户名
comment：指定注释信息
group：指定用户的主组
groups：指定用户的附属组
password：指定密码，但是必须对密码进行加密
state：此参数值如下
①present：用于创建用户。

②absent：用于删除用户。

1）下面创建一个用户lisi

[blab@node01 ~]$ ansible node02 -m user -a "name=lisi group=root password=123456 state=present"
[WARNING]: The input password appears not to have been hashed. The 'password'
argument must be encrypted for this module to work properly.
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "comment": "",
    "create_home": true,
    "group": 0,
    "home": "/home/lisi",
    "name": "lisi",
    "password": "NOT_LOGGING_PASSWORD",
    "shell": "/bin/bash",
    "state": "present",
    "system": false,
    "uid": 1003
}
[blab@node01 ~]$

????????到node02 上验证，因为root用su命令切换到任何用户都不需要密码，所以这里先切换到 lduan用户，然后再切换到lisi用户，测试密码是不是正确。

[root@node02 ~]# su - lisi
[lisi@node02 ~]$ exit
注销
[root@node02 ~]#

2）下面把lisi用户删除，命令如下。

[blab@node01 ~]$ ansible node02 -m user -a "name=lisi state=absent remove=yes"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "force": false,
    "name": "lisi",
    "remove": false,
    "state": "absent"
}
[blab@node01 ~]$

这里remove=yes的意思类似于userdel 中的-r选项，删除用户的同时把家目录也删除。

18.使用get url模块下载文件

????????如果想从服务器上下载到被管理机器上，需要使用到get_url模块。get_url模块常见的参数包括以下几个：

url：指定文件的URL连接
dest：指定存储在哪里

例如，现在要把ftp://ftp.rhce.cc/auto/web.tar.gz下载到server2的/opt目录中，命令如下。

[blab@node01 ~]$ ansible node02 -m get_url -a "url=ftp://ftp.rhce.cc/auto/web.tar.gz dest=/opt/"
node02 | CHANGED => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": true,
    "checksum_dest": null,
    "checksum_src": "0453d8c9e9ce9bda838b659b901b74a2e709fb15",
    "dest": "/opt/web.tar.gz",
    "elapsed": 1,
    "gid": 0,
    "group": "root",
    "md5sum": "41c019324f7b8160ce6944102a755de8",
    "mode": "0644",
    "msg": "OK (1406 bytes)",
    "owner": "root",
    "secontext": "system_u:object_r:usr_t:s0",
    "size": 1406,
    "src": "/home/blab/.ansible/tmp/ansible-tmp-1702885918.9421644-8590-163172471685725/tmpy3h7y39h",
    "state": "file",
    "status_code": null,
    "uid": 0,
    "url": "ftp://ftp.rhce.cc/auto/web.tar.gz"
}
[blab@node01 ~]$

然后到node02上验证，命令如下。

[root@node02 ~]# ls /opt/
11.txt  aa.txt  bb.txt  hosts  web.tar.gz
[root@node02 ~]#

可以看到，已经把文件下载下来了。

19.使用setup模块获取被管理主机信息

如果想获取被管理主机的系统信息，可以使用setup模块。下面获取node02上的信息，命令如下。

[blab@node01 ~]$ ansible node02 -m setup

setup中所获取的变量叫作fact变量，这里都是以key:value的格式输出，大致结构如下。

1 键 1 : 值

2 键 2 :{

3 子键 a : 值 a

4 子键 b : 值 b

5 ...

6 }

????????如果想获取“键1”的值,可以通过参数“filter=键”或“filter=键.子键”来过滤。例如，要获取server2上所在机器BIOS的版本，可以通过键值ansible_bios_version来获取，命令如下。

[blab@node01 ~]$ ansible node02 -m setup -a "filter=ansible_bios_version"
node02 | SUCCESS => {
    "ansible_facts": {
        "ansible_bios_version": "6.00",
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": false
}
[blab@node01 ~]$

如果想获取node02上ipv4的所有信息，可以通过键值ansible default ipv4来获取，命令如下。

[blab@node01 ~]$ ansible node02 -m setup -a "filter=ansible_default_ipv4"
node02 | SUCCESS => {
    "ansible_facts": {
        "ansible_default_ipv4": {
            "address": "192.168.182.193",
            "alias": "ens160",
            "broadcast": "192.168.182.255",
            "gateway": "192.168.182.2",
            "interface": "ens160",
            "macaddress": "00:0c:29:ba:79:52",
            "mtu": 1500,
            "netmask": "255.255.255.0",
            "network": "192.168.182.0",
            "type": "ether"
        },
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": false
}
[blab@node01 ~]$

????????如果仅仅想获取IP地址信息，其他网络信息不需要，可以通过 ansible_default_ipv4的子键来获取，命令如下。

[blab@node01 ~]$ ansible node02 -m setup -a "filter=ansible_default_ipvs.address"
node02 | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/libexec/platform-python"
    },
    "changed": false
}
[blab@node01 ~]$

????????不过在命令行中如果filter含有子键，结果是不会显示的，所以上面的命令没有看到IP.不过如果把这个键写入playbook，是会显示值的，关于 playbook后面会讲。

文章来源:https://blog.csdn.net/ls041224/article/details/135013674
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！