Ansible模块

一、user 模块

1. 在 node1 上创建一个名为 webadmin 的用户。
   ansible node1 -m user -a "name=webadmin state=present"

   • -m user: 使用user模块 -m user : 使用 user 模块

   • -a: 指定模块参数

   • name=webadmin: 要创建的用户名

   • state=present: 确保用户存在（创建用户）

2. 在 node2 上创建一个名为 monitor 的系统用户 (system: yes)。
   ansible node2 -m user -a "name=monitor system=yes state=present"

   • system=yes: 创建系统用户（UID通常小于1000）

3. 在 node1 上删除用户 testuser，并移除其家目录。
   ansible node1 -m user -a "name=testuser state=absent remove=yes"

   • state=absent: 确保用户不存在（删除用户）

   • remove=yes: 删除用户时同时删除家目录和邮件池

1. 在 node1 上创建一个名为 developers 的组，并创建一个用户 coder 使其主要组为 developers。
   ansible node1 -m group -a "name=developers state=present"
ansible node1 -m user -a "name=coder group=developers state=present"

   • 第一个命令创建组

   • 第二个命令创建用户并指定主要组

2. 在 node3 上将用户 operator 的登录 shell 改为 /sbin/nologin。
   ansible node3 -m user -a "name=operator shell=/sbin/nologin"

   • shell: 设置用户的登录shell

3. 在 node2 上为用户 admin 添加一个附加组 wheel，并保留其原有其他组。
   ansible node2 -m user -a "name=admin groups=wheel append=yes"

   • groups=wheel: 指定用户所属的附加组

   • append=yes: 将新组添加到用户现有组中，而不是替换

1. 在 node3 上创建一个用户 appuser，并设置其 UID 为 3000。
   ansible node3 -m user -a "name=appuser uid=3000 state=present"

   • uid=3000: 指定用户的UID

二、shell 和 command 模块

1. 在 node1 上使用 command 模块执行 whoami 命令。
   ansible node1 -m command -a "whoami"

   • -m command: 使用command模块（执行简单命令，不支持shell特性）

   • -a "whoami": 执行的命令

2. 在 node2 上使用 shell 模块统计 /etc/passwd 文件的行数。
   ansible node2 -m shell -a "wc -l /etc/passwd"

   • -m shell: 使用shell模块（支持管道、重定向等shell特性）

   • -a "wc -l /etc/passwd": 执行的shell命令

3. 在 node3 上使用 shell 模块在 /tmp 目录下创建一个名为 my project 的目录（注意空格）。
   ansible node3 -m shell -a "mkdir '/tmp/my project'"

4. 使用引号确保包含空格的路径被正确解析在 node1 上使用 command 模块执行 cat /etc/redhat-release 命令。
   ansible node1 -m command -a "cat /etc/redhat-release"

   • command模块适合执行不需要shell特性的简单命令

5. 在 node2 上使用 shell 模块，如果文件 /tmp/junk.txt 存在则删除它，并确保命令失败也被忽略。
   ansible node2 -m shell -a "rm -f /tmp/junk.txt"

   • -f 参数使rm命令在文件不存在时不报错

6. 在 node3 上使用 shell 模块将当前日期和时间输出到 /tmp/date.txt 文件中。
   ansible node3 -m shell -a "date > /tmp/date.txt"

   • 使用重定向操作符将输出保存到文件

7. 在 node1 上使用 raw 模块执行 uptime 命令（模拟没有Python环境）。
   ansible node1 -m raw -a "uptime"

   • -m raw: 使用raw模块（直接在SSH连接上执行命令，不依赖Python）

三、copy 模块

1. 将控制节点上的文件 /home/student/app.conf 复制到 node1 的 /etc/ 目录下。
   ansible node1 -m copy -a "src=/home/student/app.conf dest=/etc/app.conf"

   • -m copy: 使用copy模块 -m copy : 使用 copy 模块

   • src: 源文件路径（在控制节点上）

   • dest: 目标路径（在远程节点上）

2. 在 node2 上创建文件 /tmp/greeting.txt，内容为 Hello from Ansible。
   ansible node2 -m copy -a "content='Hello from Ansible' dest=/tmp/greeting.txt"

   • content: 直接指定文件内容（而不是从文件复制）

3. 将控制节点 files/ 目录下的 script.sh 复制到 node3 的 /usr/local/bin，并设置其权限为 0755。
   ansible node3 -m copy -a "src=files/script.sh dest=/usr/local/bin/script.sh mode=0755"

   • mode=0755: 设置文件权限（八进制格式）

4. 将文件 service.conf 复制到 node1 的 /etc/ 目录，并设置其所有者（owner）为 root，所属组（group）为 wheel。
   ansible node1 -m copy -a "src=files/service.conf dest=/etc/service.conf owner=root group=wheel"

   • owner: 设置文件所有者

   • group: 设置文件所属组

5. 在将新文件 nginx.conf 复制到 node2 的 /etc/nginx/ 目录覆盖原文件之前，对原文件进行备份。
   ansible node2 -m copy -a "src=files/nginx.conf dest=/etc/nginx/nginx.conf backup=yes"

   • backup=yes: 在覆盖前创建备份文件（通常以原始文件名加时间戳）

6. 使用 validate 选项在复制 sshd_config 文件到 node3 的 /etc/ssh/ 后，执行 sshd -t 验证配置是否正确。
   ansible node3 -m copy -a "src=files/sshd_config dest=/etc/ssh/sshd_config validate='sshd -t -f %s'"

   • validate: 复制后执行验证命令（%s会被替换为临时文件路径）

7. 将本地目录 web_content 递归地复制到 node1 的 /var/www/html/ 目录下。
   ansible node1 -m copy -a "src=web_content/ dest=/var/www/html/ directory_mode=yes"

   • 源路径以斜杠结尾表示复制目录内容

   • directory_mode=yes: 递归设置目录权限

四、file 模块

1. 在 node1 上创建目录 /opt/myapp。
   ansible node1 -m file -a "path=/opt/myapp state=directory"

   • -m file: 使用file模块 -m file : 使用 file 模块

   • path: 文件/目录路径

   • state=directory: 创建目录

2. 在 node2 上创建空文件 /tmp/test.file。
   ansible node2 -m file -a "path=/tmp/test.file state=touch"

   • state=touch: 创建空文件（类似touch命令）

3. 在 node3 上删除文件 /tmp/junk.txt。
   ansible node3 -m file -a "path=/tmp/junk.txt state=absent"

   • state=absent: 确保文件/目录不存在（删除）

4. 在 node1 上创建符号链接 /etc/motd 指向 /etc/issue。
   ansible node1 -m file -a "src=/etc/issue dest=/etc/motd state=link"

   • state=link: 创建符号链接

   • src: 源文件路径

   • dest: 链接文件路径

5. 在 node2 上修改文件 /etc/hosts 的权限为 644。
   ansible node2 -m file -a "path=/etc/hosts mode=0644"

   • mode: 设置文件权限（八进制格式）

6. 在 node3 上修改目录 /var/log/myapp 的所有者为 appuser，所属组为 appgroup。
   ansible node3 -m file -a "path=/var/log/myapp owner=appuser group=appgroup"

   • owner: 设置所有者

   • group: 设置所属组

7. 在 node1 上递归修改目录 /opt/data 及其所有内容的权限为 755。
   ansible node1 -m file -a "path=/opt/data mode=0755 recurse=yes"

   • recurse=yes: 递归修改目录及其内容

8. 在 node2 上创建硬链接 /usr/bin/python3-link 指向 /usr/bin/python3。
   ansible node2 -m file -a "src=/usr/bin/python3 dest=/usr/bin/python3-link state=hard"

   • state=hard: 创建硬链接

9. 在 node3 上设置文件 /etc/crontab 的 SELinux 上下文为 system_u:object_r:system_cron_spool_t:s0。
   ansible node3 -m file -a "path=/etc/crontab setype=system_cron_spool_t"

   • setype: 设置SELinux类型（需要安装libselinux-python）
     setype : 设置 SELinux 类型（需要安装 libselinux-python）

10. 在 node1 上修改目录 /srv/www 及其所有子目录的权限，但只修改目录不修改文件。
    ansible node1 -m file -a "path=/srv/www mode=0755 recurse=yes directory_mode=yes"

    • directory_mode=yes: 仅递归修改目录权限（不修改文件）

五，yum模块

[student@master ansible]$ ansible all -m yum_repository -a 'file=server name=BASE description="software base" baseurl=http://ansible.example.com/rhel9/BaseOS enabled=yes gpgcheck=yes gpgkey=http://ansible.example.com/rhel9/RPM-GPG-KEY-redhat-release'

[student@master ansible]$ ansible all -m yum_repository -a 'file=server name=STREAM description="software stream" baseurl=http://ansible.example.com/rhel9/AppStream enabled=yes gpgcheck=yes gpgkey=http://ansible.example.com/rhel9/RPM-GPG-KEY-redhat-release'

1. 在 node1 上安装 nginx 软件包。
   ansible node1 -m yum -a "name=nginx state=present"

   • -m yum: 使用yum模块 -m yum : 使用 yum 模块

   • name: 软件包名称

   • state=present: 确保软件包已安装

2. 在 node2 上安装多个软件包：vim，wget，curl。
   ansible node2 -m yum -a "name=vim,wget,curl state=present"

   • 可以指定多个软件包，用逗号分隔

3. 在 node3 上卸载 httpd 软件包。
   ansible node3 -m yum -a "name=httpd state=absent"

   • state=absent: 确保软件包未安装（卸载）

4. 在 node1 上更新所有已安装的软件包到最新版本。
   ansible node1 -m yum -a "name=* state=latest"

   • state=latest: 确保软件包是最新版本

   • name=*: 所有软件包

5. 在 node2 上安装特定版本的 nginx 软件包（例如：1.14.1）。
   ansible node2 -m yum -a "name=nginx-1.14.1 state=present"

   • 指定完整包名和版本

6. 在 node3 上从本地文件安装 RPM 包 /tmp/mypackage.rpm。
   ansible node3 -m yum -a "name=/tmp/mypackage.rpm state=present"

   • 使用本地文件路径作为包名

7. 在 node1 上安装 @development 软件包组。
   ansible node1 -m yum -a "name=@development state=present"

   • 使用@前缀指定软件包组

8. 在 node2 上禁用 GPG 检查安装一个软件包。
   ansible node2 -m yum -a "name=mypackage state=present disable_gpg_check=yes"

   • disable_gpg_check=yes: 禁用GPG检查

9. 在 node3 上仅下载 nginx 软件包而不安装。
   ansible node3 -m yum -a "name=nginx state=present download_only=yes"

   • download_only=yes: 仅下载不安装

七、service 模块

1. 在 node1 上启动 nginx 服务。
   ansible node1 -m service -a "name=nginx state=started"

   • -m service: 使用service模块

   • name: 服务名称

   • state=started: 确保服务正在运行

2. 在 node2 上停止 httpd 服务。
   ansible node2 -m service -a "name=httpd state=stopped"

   • state=stopped: 确保服务已停止

3. 在 node3 上重启 sshd 服务。
   ansible node3 -m service -a "name=sshd state=restarted"

   • state=restarted: 重启服务

4. 在 node1 上重新加载 nginx 服务的配置（不中断服务）。
   ansible node1 -m service -a "name=nginx state=reloaded"

   • state=reloaded: 重新加载服务配置

5. 在 node2 上启用 httpd 服务开机自启动。
   ansible node2 -m service -a "name=httpd enabled=yes"

   • enabled=yes: 启用服务开机自启动

6. 在 node3 上禁用 firewalld 服务开机自启动。
   ansible node3 -m service -a "name=firewalld enabled=no"

   • enabled=no: 禁用服务开机自启动

7. 在 node1 上检查 nginx 服务的当前状态。
   ansible node1 -m service -a "name=nginx"

   • 不指定state参数，只检查状态

八、fetch 模块

1. 将 node1 上的 /etc/fstab 文件拉取到控制节点的 /tmp 目录，并保持主机目录结构。
   ansible node1 -m fetch -a "src=/etc/fstab dest=/tmp"

   • -m fetch: 使用fetch模块 -m fetch : 使用 fetch 模块

   • src: 远程节点上的源文件路径

   • dest: 控制节点上存储的目录，会自动创建以主机名命名的子目录

2. 将 node2 上的 /etc/hosts 文件拉取到控制节点的 /tmp 目录，并保持主机目录结构。
   ansible node2 -m fetch -a "src=/etc/hosts dest=/tmp"

1. 将 node1 上的 /etc/fstab 文件拉取到控制节点的 /tmp 目录，并扁平化存储（不创建主机目录结构），保存为 /tmp/fstab-node1。
   ansible node1 -m fetch -a "src=/etc/fstab dest=/tmp/fstab-node1 flat=yes"

   • flat=yes: 不创建主机目录结构，直接存储到dest指定的路径（如果多个主机，会覆盖，所以一般用于单台主机）

2. 将 node2 上的 /etc/yum.conf 文件拉取到控制节点的 /tmp 目录，并扁平化存储，保存为 /tmp/yum.conf-node2。
   ansible node2 -m fetch -a "src=/etc/yum.conf dest=/tmp/yum.conf-node2 flat=yes"

1. 将 node1 上的 /etc/ssh/sshd_config 文件拉取到控制节点的 /tmp 目录，并验证文件MD5值。
   ansible node1 -m fetch -a "src=/etc/ssh/sshd_config dest=/tmp validate_checksum=yes"

   • validate_checksum=yes: 拉取后验证源文件和目标文件的MD5校验和

2. 将 node2 上的 /boot/grub2/grub.cfg 文件拉取到控制节点的 /tmp 目录，并保持文件权限。
   ansible node2 -m fetch -a "src=/boot/grub2/grub.cfg dest=/tmp"

   • 默认情况下，fetch模块会尝试保持原始权限

   • 将 node1 上的 /etc/resolv.conf 文件拉取到控制节点的 /tmp 目录，如果目标文件已存在则覆盖。
     ansible node1 -m fetch -a "src=/etc/resolv.conf dest=/tmp force=yes"

     • force=yes: 覆盖已存在的文件（默认是no，即如果文件已存在则跳过）

九、firewalld 模块

1. 在 node1 上永久开放 HTTP 服务（80端口）。
   ansible node1 -m firewalld -a "service=http permanent=yes state=enabled"

   • -m firewalld: 使用firewalld模块 -m firewalld : 使用 firewalld 模块

   • service: 服务名称（预定义的，如http、https等）

   • permanent=yes: 永久生效（重启后仍有效）

   • state=enabled: 启用规则

2. 在 node2 上永久开放 HTTPS 服务（443端口）。
   ansible node2 -m firewalld -a "service=https permanent=yes state=enabled"

3. 在 node3 上永久开放 8080/tcp 端口。
   ansible node3 -m firewalld -a "port=8080/tcp permanent=yes state=enabled"

   • port: 直接指定端口和协议

4. 在 node1 上永久移除 HTTP 服务（80端口）的放行规则。
   ansible node1 -m firewalld -a "service=http permanent=yes state=disabled"

5. 在 node2 上临时开放 22/tcp 端口（重启firewalld后失效）。
   ansible node2 -m firewalld -a "port=22/tcp state=enabled"

   • 不设置permanent或设置为no，则临时生效

6. 在 node3 上将源IP 192.168.1.0/24 加入永久信任区域（zone）。
   ansible node3 -m firewalld -a "source=192.168.1.0/24 zone=trusted permanent=yes state=enabled"

   • source: 指定源IP或网段

   • zone: 指定区域（如trusted、public等）
     zone : 指定区域（如可信、公共等）

7. 在 node1 上设置默认区域为 dmz。
   ansible node1 -m firewalld -a "zone=dmz state=present permanent=yes default_zone=yes"

   • default_zone=yes: 设置为默认区域

8. 在 node2 上查询 public 区域当前设置。
   ansible node2 -m firewalld -a "zone=public state=info"

   • state=info: 查询信息

9. 在 node3 上永久添加一个富规则，允许来自 10.0.0.1 的所有流量。
   ansible node3 -m firewalld -a "rich_rule='rule family=ipv4 source address=10.0.0.1 accept' permanent=yes state=enabled"

   • rich_rule: 富规则字符串

10. 在 node1 上重新加载防火墙规则（不中断现有连接）。
    ansible node1 -m firewalld -a "state=reloaded"

    • state=reloaded: 重新加载防火墙规则

十、replace 模块

• -m replace: 使用replace模块 -m replace : 使用 replace 模块

• path: 文件路径

• regexp: 正则表达式匹配要替换的文本

• replace: 替换后的文本

1. 在 node2 上的 /etc/nginx/nginx.conf 中，将 worker_processes 1; 替换为 worker_processes 2;。
   ansible node2 -m replace -a "path=/etc/nginx/nginx.conf regexp='worker_processes 1;' replace='worker_processes 2;'"

2. 在 node3 上的 /etc/sysconfig/selinux 中，将 SELINUX=enforcing 替换为 SELINUX=disabled。
   ansible node3 -m replace -a "path=/etc/sysconfig/selinux regexp='SELINUX=enforcing' replace='SELINUX=disabled'"

十一、parted 模块

1. 在 node1 的 /dev/sdb 磁盘上创建一个新的 GPT 分区表。
   ansible node1 -m parted -a "device=/dev/sdb label=gpt"

   • -m parted: 使用parted模块 -m parted : 使用 parted 模块

   • device: 磁盘设备

   • label: 分区表类型（如gpt、msdos）

2. 在 node2 的 /dev/sdc 磁盘上创建一个大小为 2GB 的主分区。
   ansible node2 -m parted -a "device=/dev/sdc number=1 part_type=primary size=2GB"

   • number: 分区编号

   • part_type: 分区类型（primary、extended、logical）
     part_type : 分区类型（主分区、扩展分区、逻辑分区）

   • size: 分区大小

3. 在 node3 的 /dev/sdd 磁盘上创建一个占据所有剩余空间的分区。
   ansible node3 -m parted -a "device=/dev/sdd number=1 part_type=primary state=present"

   • 不指定size则使用所有剩余空间

4. 在 node1 的 /dev/sdb 磁盘上删除第 1 个分区。
   ansible node1 -m parted -a "device=/dev/sdb number=1 state=absent"

   • state=absent: 删除分区

5. 在 node2 的 /dev/sdc 磁盘上创建一个大小为 1GB 的交换分区（文件系统类型为linux-swap）。
   ansible node2 -m parted -a "device=/dev/sdc number=2 part_type=primary size=1GB fs_type=linux-swap"

   • fs_type: 设置文件系统类型（在parted中设置标志）

6. 在 node3 的 /dev/sdd 磁盘上将分区表从 MBR 改为 GPT。
   ansible node3 -m parted -a "device=/dev/sdd label=gpt"

   • 注意：这会破坏现有分区表

7. 在 node1 的 /dev/sdb 磁盘上创建一个起始于 1GB，结束于 3GB 的分区。
   ansible node1 -m parted -a "device=/dev/sdb number=1 part_type=primary start=1GB end=3GB"

   • start: 分区起始位置

   • end: 分区结束位置

8. 在 node2 的 /dev/sdc 磁盘上调整第 1 个分区的大小，将其扩大到 3GB。
   ansible node2 -m parted -a "device=/dev/sdc number=1 part_end=3GB"

   • part_end: 调整分区的结束位置（扩大分区）

9. 在 node3 的 /dev/sdd 磁盘上设置第 1 个分区的标志为 boot。
   ansible node3 -m parted -a "device=/dev/sdd number=1 flags=[boot]"

   • flags: 设置分区标志

10. 在 node1 的 /dev/sdb 磁盘上列出所有分区的信息。
    ansible node1 -m parted -a "device=/dev/sdb unit=MB print"

    • print: 打印分区信息

    • unit: 显示单位（如MB、GB）

十二、mount 模块

1. 在 node1 上挂载 /dev/sdb1 到 /mnt/data。
   ansible node1 -m mount -a "path=/mnt/data src=/dev/sdb1 fstype=ext4 state=present"

   • -m mount: 使用mount模块 -m mount : 使用 mount 模块

   • path: 挂载点路径

   • src: 要挂载的设备或文件系统

   • fstype: 文件系统类型

   • state=present: 确保挂载点存在（并挂载）

2. 在 node2 上卸载 /mnt/temp 挂载点。
   ansible node2 -m mount -a "path=/mnt/temp state=absent"

   • state=absent: 卸载并删除挂载点

3. 在 node3 上永久挂载 /dev/sdc1 到 /opt/app，文件系统类型为 xfs。
   ansible node3 -m mount -a "path=/opt/app src=/dev/sdc1 fstype=xfs state=mounted"

   • state=mounted: 立即挂载并写入fstab

4. 在 node1 上永久挂载 NFS 共享 192.168.1.100:/share 到 /mnt/nfs。
   ansible node1 -m mount -a "path=/mnt/nfs src=192.168.1.100:/share fstype=nfs opts=defaults state=mounted"

   • opts: 挂载选项

5. 在 node2 上重新挂载 /mnt/data 为只读。
   ansible node2 -m mount -a "path=/mnt/data opts=ro state=remounted"

   • state=remounted: 重新挂载

6. 在 node3 上确保 /mnt/backup 在 fstab 中有配置但当前未挂载。
   ansible node3 -m mount -a "path=/mnt/backup src=/dev/sdd1 fstype=ext4 state=unmounted"

   • state=unmounted: 确保未挂载，但fstab中有配置

7. 在 node1 上从 fstab 中移除 /mnt/old 的配置，并确保未挂载。
   ansible node1 -m mount -a "path=/mnt/old state=absent"