千锋教育Ansible自动化运维实战教程从入门到精通

简介

介绍 Ansible 的基本概念、自动化运维优势、应用场景及课程目标。

欢迎开启 Ansible 学习之旅！

你好！作为一名学习者，你即将通过这个 Ansible 自动化运维实战 课程，从零开始掌握自动化运维的超能力！这个"简介"章节就像你的起跑线，帮你快速搞清楚 Ansible 是什么、为什么重要，以及这门课会带你去哪儿。准备好笔记本（或好奇心），我们开始吧！

---

1. Ansible 是什么？它能帮你做什么？

就像一个智能遥控器，Ansible 让你轻松管理一大群服务器！

Ansible 是个啥？

• Ansible 是一个开源的自动化运维工具，简单说，它能帮你自动完成服务器上的重复工作，比如安装软件、修改配置文件、启动服务。它用 Python 写成，最大的特点是简单和无需额外软件------只要服务器能用 SSH 登录，Ansible 就能工作！

它能干啥？

• 想象一下，你有 10 台、100 台，甚至 1000 台服务器，要给每台都装 Nginx 或者改个配置。手动操作得累死吧？Ansible 让你写几行命令或脚本，就能同时搞定所有服务器！

  • 例子：用一条命令给所有服务器装上 Python。

  • 再比如：自动配置定时任务，每天备份数据库。

它跟其他工具比有什么优势？

• 像 Puppet 或 Chef 也做自动化，但它们需要服务器装额外软件，配置复杂。Ansible 不用装客户端，用 YAML（一种超级简单的语言）写脚本，新手也能快速上手！

学习小结：

Ansible 就像你的"运维助手"，帮你批量管理服务器，省时省力。学会它，你就能从繁琐的手动操作中解放出来！

---

2. 为什么你要学 Ansible？

因为它能让你的工作更高效，职业更有竞争力！

自动化运维有多重要？

• 在现在的工作中，手动配置服务器又慢又容易出错。Ansible 能让你的操作快、准、稳：

  • 省时间：一键配置几十台服务器，几秒钟搞定。

  • 少出错：自动化保证每台服务器配置一致，不用担心手抖输错。

  • 易扩展：管理 1 台和 1000 台服务器，工作量差不多！

谁需要 Ansible？

• 系统管理员：批量管理服务器，配置环境。

• 运维工程师：自动化部署应用、监控任务。

• 开发者：快速搭建测试环境，管理云服务。

• 甚至如果你是学生，学 Ansible 能让你在云计算、DevOps 领域抢先一步！

学了有啥回报？

• Ansible 是 DevOps 和云计算的热门技能，全球大公司（像 AWS、Google）都在用。掌握它，你的简历会更亮眼，面试时也能自信聊自动化！

学习小结：

学 Ansible 不仅能让你的工作更轻松，还能提升职业技能，尤其在云计算和 DevOps 领域，Ansible 是你的"加分项"！

---

3. Ansible 怎么工作的？（核心概念）

别怕复杂，它其实就像玩"乐高"！

Ansible 的工作方式很简单：你在一台电脑（控制节点）上用 Ansible 发指令，告诉远端的服务器（被控节点）干啥活儿。下面是它的三个核心"零件"：

主机清单（Inventory）

• 就像你的"通讯录"，列出你要管理的服务器（比如 IP 地址或域名）。

  • 例子：你写一个文件，列出 192.168.1.10 和 192.168.1.11，Ansible 就知道要管这两台机器。

模块（Modules）

• 模块是 Ansible 的"小工具"，每个模块干一件具体的事。

  • 比如：copy 模块帮你传文件，service 模块启动或停止服务。

  • Ansible 有几百个模块，覆盖几乎所有运维需求，超级方便！

剧本（Playbooks）

• Playbook 是 Ansible 的"剧本"，用 YAML 语言（长得像清单）写，告诉服务器按顺序干一堆事。

  • 比如：一个 Playbook 可以说"先装 Nginx，再改配置文件，最后启动服务"。

  • 好消息：YAML 超简单，像写便签，不用怕代码！

额外提一句：Ad-hoc 命令

• 如果你只想快速干一件事（比如查所有服务器的磁盘空间），可以用 Ad-hoc 命令，敲一行就搞定，不用写 Playbook。

学习小结：

Ansible 的核心是"主机清单+模块+剧本"。你只要告诉它"管谁、干啥、怎么干"，它就自动完成，简单又强大！

---

4. 这门课会带你学什么？

从零到部署一个 Nginx 网站，你会成为 Ansible 小能手！

课程目标：

• 这门课会带你从 Ansible 的基础学到实战，目标是让你：

  • 掌握 Ansible 的核心功能（配置环境、管理服务器）。

  • 学会写 Playbook，自动化完成复杂任务。

  • 最终能用 Ansible 自动部署一个 Nginx 网站（从安装到配置全搞定）！

课程结构：

• 这门课有 16 个章节，像一个完整的"冒险故事"：

  1. 基础篇（前几章）：教你搭环境、装 Ansible、测试连接、配置主机清单。

  2. 模块篇：学会用各种模块（比如拷贝文件、管理服务、设置定时任务）。

  3. 进阶篇：掌握 YAML 语言，写 Playbook 自动化任务。

  4. 实战篇：用 Ansible 部署 Nginx，包括配置网站、测试运行。

适合谁学？

• 你只需要一点 Linux 基础（比如会用 SSH 登录服务器、敲基本命令）。

• 完全零基础也没关系，课程会一步步带你上手！

• 如果你已经有点运维经验，学这个能让你的技能更系统化。

学习小结：

这门课就像一个"从新手到高手"的旅程。你会从认识 Ansible 开始，最后能用它自动部署一个真实的 Web 服务器，成就感爆棚！

---

5. 学习建议（给你的小贴士）

让你的学习更轻松、更高效！

• 认真听这一章：简介是全课程的"导航"，多花点时间搞懂 Ansible 的概念（比如 Inventory、Playbook），后面学起来会更顺。

• 记笔记：记下几个核心词（模块、Playbook、YAML），可以用自己的话总结，比如"Playbook 就是自动化脚本"。

• 想一想你的场景：你想用 Ansible 干啥？比如管几台云服务器、搭个测试环境？带着目标学，动力更足！

• 别怕动手：这一章主要是理论，但你可以提前准备一台 Linux 电脑（或虚拟机），后面会用到。

• 遇到问题别慌：如果对 SSH、YAML 这些词不熟，随时问我，我会用大白话解释！

---

你的收获

学完这一章，你会：

• 知道 Ansible 是什么，能解决啥问题（批量管理服务器、自动化任务）。

• 明白学 Ansible 的价值（省时间、加技能）。

• 了解 Ansible 的核心部件（主机清单、模块、剧本），对它的工作方式有直观感受。

• 清楚课程的目标和内容，带着期待进入下一章（实验环境搭建）！

---

下一步

下一章（实验环境）会带你动手搭一个 Ansible 的"实验室"，准备好控制节点和被控节点，真正开始玩起来！如果你有云服务器（比如阿里云、AWS）或者电脑能装虚拟机，可以提前准备一下。

有问题？

• 对 Ansible 的某个概念（比如 YAML 或者模块）不明白？

• 想知道 Ansible 能不能解决你的具体需求（比如管理某台服务器）？

• 告诉我你的情况，我会帮你解答或定制解释！

准备好了吗？让我们一起开启 Ansible 的自动化冒险吧！

实验环境与服务端安装

太棒了，你进入了Ansible实战最关键的一步------实验环境搭建。只要你动手搭一次，理解执行过程和Playbook语法都会顺很多。我们来一步步搞定：

---

🧪 一、整体目标（实验环境组成）

你将搭建如下环境：

[控制节点 Control Node]             [受控节点 Managed Nodes]
         Ubuntu                        CentOS / Ubuntu
        (安装 Ansible)               (通过 SSH 被控制)

---

✅ 二、系统准备

角色	系统版本建议	数量	说明
控制节点	Ubuntu 20.04 或更高	1	用于安装并运行 Ansible
受控节点	CentOS 7/8 or Ubuntu	1~2	可被远程控制的目标机

🧠 可以用 VMware / VirtualBox 搭多台虚拟机，或者用 Multipass 快速生成 Ubuntu VM。

---

✅ 三、安装 Ansible（控制节点）

以下以 Ubuntu 为例：

sudo apt update
sudo apt install ansible -y
ansible --version  # 确认安装成功

CentOS 控制节点的话，可用：

sudo yum install epel-release -y
sudo yum install ansible -y

---

✅ 四、配置 SSH 互信（控制节点 ↔ 受控节点）

🔑 步骤：

1. 生成 SSH 密钥对（在控制节点执行）：

   ssh-keygen -t rsa # 一路回车即可

2. 将公钥拷贝到受控节点：

   ssh-copy-id user@受控节点IP

例如：

ssh-copy-id [email protected]

1. 测试登录是否成功：

   ssh [email protected]

---

✅ 五、配置 Inventory（主机清单）

编辑 /etc/ansible/hosts 或自定义文件（这里是在控制节点中完成，放受控节点IP地址）：

[web]
192.168.56.11

[db]
192.168.56.12 ansible_user=root

---

✅ 六、测试连通性

ansible all -m ping

输出类似：

192.168.56.11 | SUCCESS => {"changed": false, "ping": "pong"}

说明配置成功 🎉

---

✅ 七、网络配置建议（虚拟机场景）

• 使用 NAT + Host-Only 双网卡，确保：

  • 主机可以 ping 通虚拟机 IP；

  • 虚拟机之间能相互通信（SSH）。

---

🧠 补充小提示（记忆）

控制节点：我发命令，  
受控节点：我执行脚本，  
SSH 是桥梁，  
Inventory 是地图。

服务端测试

测试 Ansible 服务端是否正常工作，包括连接测试、基本命令验证。

✅ 一、连接测试（Connection Test）

🎯 目标：确认控制节点可以无密码 SSH 到受控节点。

🔍 命令：

ansible all -m ping

📘解释：

• all：代表 inventory 中的所有主机；

• -m ping：调用 Ansible 自带的 ping 模块（不是系统 ping 命令）。

✅ 成功输出样例：

192.168.56.11 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

❌ 错误样例（无 SSH 权限）：

192.168.56.11 | UNREACHABLE! => {
    "msg": "Permission denied (publickey,password)..."
}

👉 解决方法：ssh-copy-id 重新传公钥。

---

✅ 二、命令模块测试（Ad-Hoc 命令）

🎯 目标：确认 Ansible 能正常执行远程命令。

示例 1：远程执行 shell 命令

ansible all -m shell -a "uptime"

输出类似：

192.168.56.11 | SUCCESS | rc=0 >>
 10:17:36 up 10 min,  1 user,  load average: 0.00, 0.01, 0.05

示例 2：查看磁盘空间

ansible all -m shell -a "df -h"

---

✅ 三、拷贝文件测试（copy 模块）

🎯 目标：确认能推送文件到远程主机。

测试命令：

ansible all -m copy -a "src=/etc/hosts dest=/tmp/hosts_copy"

然后去目标机 /tmp 下验证。

---

✅ 四、Playbook 执行测试（可选）

新建一个简单 playbook 文件：

# test.yml
- hosts: all
  tasks:
    - name: 测试 ping
      ping:

执行：

ansible-playbook test.yml

成功输出：

TASK [测试 ping] ***
ok: [192.168.56.11]

---

✅ 五、服务端状态总结 checklist

测试项目	命令	判断标准
SSH 连通性测试	ansible all -m ping	返回 pong
模块执行能力	ansible all -m shell -a "uptime"	正常输出系统信息
文件推送能力	ansible all -m copy	文件成功传到远程
playbook 执行能力	ansible-playbook xxx.yml	正常执行任务，状态为 OK

主机清单1

介绍 Ansible 主机清单（Inventory）的基本概念和配置方法。

📘**Ansible 主机清单（Inventory）**是 Ansible 控制目标主机的"地图"，是你告诉 Ansible："我需要远程管理这些主机"。如果说 Ansible 是一个指挥官，那 Inventory 就是部队名单。

我们从 概念→语法→配置→技巧 一步步来讲解，配合中英文讲解，方便你四级备考的同时打好运维基础。

---

🔹一、什么是主机清单？What is Inventory?

**Inventory（主机清单）**是一个文件，列出了所有你想控制的远程主机，它可以是：

• 一个静态文件（通常是 INI 或 YAML 格式）；

• 一个动态脚本/插件（例如自动拉取云服务器列表）；

📁 默认位置是：/etc/ansible/hosts

---

🔹二、最基础的主机清单格式（INI）

# 直接列出 IP 或主机名
192.168.56.11
server1.example.com

📘 默认使用当前登录用户连接主机（可自定义）。

---

🔹三、使用分组（Grouping）

[web]
192.168.56.11
192.168.56.12

[db]
192.168.56.21

[all_servers:children]
web
db

📘说明：

• [] 表示一个组名；

• :children 表示这个组包含子组。

👉 命令使用示例：

ansible web -m ping

表示只 ping web 组中的主机。

---

🔹四、自定义变量（变量写法）

[web]
192.168.56.11 ansible_user=root ansible_port=22

[db]
192.168.56.21 ansible_user=admin ansible_ssh_private_key_file=~/.ssh/id_rsa

📘解释：

• ansible_user：登录用户；

• ansible_port：SSH 端口；

• ansible_ssh_private_key_file：私钥路径。

---

🔹五、YAML 格式（更适合大型项目）

你也可以用 YAML 格式：

all:
  children:
    web:
      hosts:
        192.168.56.11:
          ansible_user: root
        192.168.56.12:
          ansible_user: ubuntu
    db:
      hosts:
        192.168.56.21:

在运行命令时用 -i 指定：

ansible all -i inventory.yaml -m ping

---

🔹六、常用技巧总结

功能	方法
指定 inventory 文件	ansible -i custom_inventory.ini all -m ping
查看主机列表	ansible-inventory --list（YAML 格式）
分组管理	使用 [组名] 分组
多变量支持	在清单中添加主机变量或 group_vars

---

📌一句话记忆法（中英结合）

🎓 "Inventory is the brain of Ansible." ------ 它告诉 Ansible 该管谁、怎么连、用什么身份！

---

需要我帮你生成一个 真实可用的主机清单模板文件供你练手吗？或者用 HTML 给你整理成文档页面？

主机清单2

深入探讨主机清单的高级用法，如分组、变量定义。

太棒了！你已经掌握了主机清单（Inventory）的基础，现在我们来一波进阶讲解 ：💡分组嵌套、变量控制、组合使用、多环境管理。

这是运维面试、日常部署、Playbook 精准控制的核心技能！

---

🧠 一、回顾：什么是 Inventory？

Inventory 是 Ansible 控制的主机清单，就像一个主机通讯录，包含：

• 主机 IP / 名称

• 连接方式 / 变量

• 分组组织

---

📘 二、分组进阶用法

✅ 嵌套分组（Nested Group）

[web]
192.168.10.11
192.168.10.12

[db]
192.168.10.21

[prod:children]
web
db

🧠 理解：prod 是"生产环境"，它下面套了 web 和 db 两组主机。

🌟 使用 ansible prod -m ping 可以一口气控制这两个组。

---

✅ 分组变量（Group Variables）

[web]
192.168.10.11
192.168.10.12

[web:vars]
ansible_user=ubuntu
ansible_port=22
nginx_port=80

📘说明：

• web:vars 给 web 组里所有主机设置变量；

• 在 Playbook 中可以用 {``{ nginx_port }} 读取。

---

📘 三、主机变量（Host Variables）

[db]
192.168.10.21 ansible_user=root ansible_port=2222 db_port=3306 ansible_ssh_pass='6666'

🔍 每台主机有自己专属的参数。优先级高于分组变量。

👉 建议全部换成新版写法，旧的依然兼容，但未来可能弃用。

老变量名	推荐新变量名(2.0+)	说明
ansible_ssh_user	ansible_user	SSH 登录用户名
ansible_ssh_port	ansible_port	SSH 端口
ansible_ssh_host	ansible_host	实际连接 IP 地址
ansible_ssh_pass	ansible_password	SSH 密码（不推荐明文）
ansible_ssh_private_key_file	ansible_private_key_file	SSH 私钥文件路径
ansible_ssh_common_args	ansible_ssh_common_args	连接的额外参数（如跳板机）

---

📁 四、文件夹结构化写法（推荐）

更适合大型项目或多人协作，Ansible 支持 目录化变量管理：

inventory/
├── hosts
├── group_vars/
│   ├── web.yml
│   └── db.yml
├── host_vars/
│   └── 192.168.10.21.yml

✨ 示例：group_vars/web.yml

ansible_user: ubuntu
nginx_port: 8080

✨ 示例：host_vars/192.168.10.21.yml

db_user: root
db_password: secret123

🔑 优点：

• 易于维护；

• 可按环境、主机自定义不同参数；

• Playbook 无需硬编码变量。

---

📘 五、Inventory 优先级（重要）

变量生效的优先级从低到高是：

1. 全局变量（例如 /etc/ansible/ansible.cfg）
2. group_vars（分组变量）
3. host_vars（主机变量）
4. 命令行传入变量（-e）

🔔结论：命令行变量最大，host_vars 高于 group_vars。

---

📘 六、动态主机清单（进阶）

适用于 AWS、阿里云等云平台自动拉取主机：

ansible -i aws_ec2.yaml all -m ping

👉 需要安装相关插件，比如：

pip install boto boto3

---

🎓 中英总结一句话：

"Group your hosts, define their personalities, and let Ansible orchestrate with precision."

------ 把主机分组，赋予角色，Ansible 就能精准调度！

ansible怎么用？

本小节ansible命令怎么用，格式是怎么样的，怎么用剧本等。

Ansible 是一个非常强大的自动化工具，广泛应用于配置管理、应用部署和任务自动化。它可以通过简单的命令行操作，也可以通过编写剧本（Playbook）来执行任务。接下来我们将介绍如何使用 Ansible 命令和编写剧本。

1. Ansible 命令行基础

Ansible 命令行工具非常简洁，通常包含一个基本的命令结构，语法格式如下：

ansible <host-pattern> -m <module> -a "<module-arguments>"

• <host-pattern>：指定要执行命令的目标主机，可以是主机名、主机组、IP 地址等。

• -m <module> ：指定要使用的 Ansible 模块。Ansible 内置了很多模块（如 ping、copy、yum 等），每个模块有不同的功能。

• -a "<module-arguments>" ：模块的参数，传递给模块执行的具体任务。例如，在 ping 模块中，你可以指定主机 IP 来测试连接。

示例 1：Ping 测试

使用 ping 模块测试与主机的连接：

ansible all -m ping

• all：指定所有主机。

• -m ping ：使用 ping 模块测试连接。

示例 2：复制文件到远程主机

使用 copy 模块将文件从本地复制到远程主机：

ansible all -m copy -a "src=/path/to/local/file dest=/path/to/remote/file"

• -m copy ：使用 copy 模块。

• -a "src=/path/to/local/file dest=/path/to/remote/file"：指定源文件和目标文件路径。

示例 3：安装软件包

使用 yum 或 apt 模块来安装软件（根据目标主机的操作系统类型）：

ansible all -m yum -a "name=httpd state=present"

• -m yum ：使用 yum 模块，适用于 RedHat/CentOS 系统。

• -a "name=httpd state=present" ：安装 httpd 软件包，state=present 表示软件包应该安装。

示例 4：执行自定义 Shell 命令

使用 shell 模块执行自定义的 Shell 命令：

ansible all -m shell -a "echo Hello, Ansible!"

• -m shell ：使用 shell 模块执行命令。

• -a "echo Hello, Ansible!" ：执行简单的命令 echo。

---

2. Ansible Playbook 基础

Ansible Playbook 是一组任务（tasks）的集合，它们按顺序在目标主机上执行。Playbook 是以 YAML 格式编写的，能够更加灵活、结构化地定义和执行任务。

Playbook 结构

一个基本的 Playbook 包括以下部分：

• hosts：指定 Playbook 要运行的目标主机或主机组。

• tasks：定义需要在目标主机上执行的任务。

• name：任务名称。

• module：要执行的模块及其参数。

示例 1：简单的 Playbook

---
- name: Ensure httpd is installed and running
  hosts: webservers
  tasks:
    - name: Install httpd package
      yum:
        name: httpd
        state: present

    - name: Start httpd service
      service:
        name: httpd
        state: started

• name：Playbook 的名称（这对于理解 Playbook 的目的非常有帮助）。

• hosts ：指定要运行任务的主机组，在这里是 webservers（可以在 Ansible 主机清单中定义）。

• tasks：定义了两个任务：

  • 安装 httpd 包。

  • 启动 httpd 服务。

Playbook 执行命令

你可以使用 ansible-playbook 命令来执行 Playbook：

ansible-playbook /path/to/playbook.yml

这会运行指定的 Playbook 文件，执行其中定义的所有任务。

示例 2：执行多个任务的 Playbook

下面是一个更加复杂的示例，涉及多个任务和条件判断：

---
- name: Install and configure Apache
  hosts: webservers
  tasks:
    - name: Install Apache HTTPD
      yum:
        name: httpd
        state: present

    - name: Start Apache service
      service:
        name: httpd
        state: started

    - name: Create a custom index.html
      copy:
        content: "<html><body><h1>Welcome to Ansible</h1></body></html>"
        dest: /var/www/html/index.html
        owner: apache
        group: apache
        mode: '0644'

• 这个 Playbook 安装并配置 Apache HTTPD，并通过 copy 模块将自定义的 index.html 文件部署到远程主机上。

---

3. 运行 Playbook 时使用的选项

• -i ：指定主机清单文件，默认情况下，Ansible 会使用 /etc/ansible/hosts 作为主机清单。如果你有其他路径的清单文件，可以使用 -i 参数指定。

  ansible-playbook -i /path/to/inventory /path/to/playbook.yml

• --check：执行干运行（即模拟运行），不实际修改任何目标主机，只显示会进行哪些更改。

  ansible-playbook /path/to/playbook.yml --check

• --diff：查看变更的内容，特别适用于修改文件的任务，它会显示文件内容的差异。

  ansible-playbook /path/to/playbook.yml --diff

• -u：指定远程登录用户（如果主机清单中未设置）。

  ansible-playbook -i inventory /path/to/playbook.yml -u username

• --limit ：限制 Playbook 运行的主机。可以使用 --limit 参数仅在指定主机上运行 Playbook。

  ansible-playbook /path/to/playbook.yml --limit webservers

---

4. 变量和条件语句

你可以在 Playbook 中使用变量和条件语句，使 Playbook 更加动态和灵活。

示例 3：使用变量

---
- name: Install a package using a variable
  hosts: all
  vars:
    package_name: nginx
  tasks:
    - name: Install nginx
      yum:
        name: "{{ package_name }}"
        state: present

• 这里使用了 vars 定义了一个名为 package_name 的变量，然后通过 yum 模块来安装指定的包。

示例 4：使用条件语句

---
- name: Install a package based on condition
  hosts: all
  tasks:
    - name: Install nginx
      yum:
        name: nginx
        state: present
      when: ansible_os_family == "RedHat"

• 该任务只会在目标主机的操作系统是 RedHat 时执行。

---

总结：

• Ansible 命令行 ：通过 ansible 命令直接执行单个模块，如 ping、yum、copy 等。可以快速在远程主机上执行操作。

• Ansible Playbook ：通过 ansible-playbook 命令运行剧本（Playbook），可以执行多个任务，适用于更复杂的自动化需求。

• 模块和任务 ：在命令行和 Playbook 中，你都可以使用模块来执行任务，模块有很多种，例如 yum（包管理）、copy（复制文件）、service（服务管理）等。

• 灵活性：你可以在 Playbook 中使用条件语句、变量、循环等增强灵活性。

通过 Ansible，你可以方便地进行自动化配置管理、部署和维护，节省大量手动操作的时间和精力。

拷贝模块1

讲解 copy 模块，用于文件传输的基本操作和参数。

我们来系统、详细、易懂 地把 Ansible 的 copy 模块讲个清楚明白，让你不仅会用，还能举一反三，甚至应付面试 🧠💪！

---

🧭 一、copy 模块的作用

✅ 功能：将控制端（Ansible 控制机）上的文件、目录、或文字，拷贝到被管理主机上。

适合：

• 分发配置文件（如 nginx.conf、.bashrc）；

• 分发脚本（如 deploy.sh）；

• 生成远程文件（带变量）；

• 初始化环境（比如一键复制全套目录）；

---

🔧 二、参数详细说明（超级全！）

参数名	类型	说明	示例
src	字符串	控制机上的本地文件路径	/home/user/config.conf
dest	字符串	被管理主机上的目标路径	/etc/config.conf
owner	字符串	设置远程文件的属主	root、nginx
group	字符串	设置属组	root、staff
mode	字符串	设置文件权限（八进制）	'0644'（引号不能省）
content	字符串	写内容生成文件，代替 src	"Hello {``{ ansible_hostname }}"
backup	bool	目标文件存在时是否备份	yes 或 no
force	bool	文件存在时是否强制覆盖	默认 yes
validate	字符串	拷贝前验证文件合法性	nginx -t -c %s

---

🧪 三、使用场景举例（进阶级别！）

✅ 1. 最基础的拷贝文件（配合 ad-hoc 命令）

ansible all -m copy -a "src=/home/user/index.html dest=/var/www/html/index.html"

✅ 2. 使用 playbook 拷贝文件并设置权限

- name: 拷贝 nginx 配置文件
  hosts: web
  tasks:
    - name: 拷贝 nginx.conf
      ansible.builtin.copy:
        src: ./files/nginx.conf
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: '0644'
        backup: yes

---

✅ 3. 直接用 content 写文件

- name: 写一个简单的标志文件
  hosts: all
  tasks:
    - name: 写入系统标识
      copy:
        content: "System: {{ inventory_hostname }}\nTime: {{ ansible_date_time.date }}"
        dest: /etc/sys_tag.txt
        owner: root
        group: root
        mode: '0600'

🌟 好处：不用本地写文件，可以动态生成内容。

---

✅ 4. 拷贝脚本但不覆盖已有内容

- name: 拷贝安装脚本，但不覆盖已有的
  hosts: all
  tasks:
    - name: 分发脚本
      copy:
        src: ./scripts/install.sh
        dest: /usr/local/bin/install.sh
        mode: '0755'
        force: no

---

✅ 5. 验证拷贝后的配置文件合法性（validate）

- name: 拷贝 nginx 配置文件并验证语法
  hosts: web
  tasks:
    - name: 校验并拷贝 nginx.conf
      copy:
        src: ./files/nginx.conf
        dest: /etc/nginx/nginx.conf
        validate: nginx -t -c %s

💡 %s 表示 Ansible 会用文件路径替换它，确保你传的文件在目标主机上能被测试命令使用。

---

🧠 四、常见错误提醒（重要）

问题	可能原因	解决方法
src 找不到	你写的是控制机的路径	确保路径存在、权限正确
dest 无权限	目标主机上无写权限	加 become: true 或换用户
mode 报错	数字没加引号	要写 '0644' 而不是 0644
内容没变	文件没变化、force=no	加 force: yes

---

🧭 五、推荐使用习惯

• 文件多 → 放在 files/ 文件夹；

• 动态内容 → 用 template 模块代替；

• 内容重要 → 加上 backup: yes；

• 要调试 → 用 diff: yes 让 Ansible 显示文件差异；

---

📌 总结一句话（中英记忆）：

"copy is for static files; if you want magic, use template."

------ copy 用来发死文件，灵活的配置文件推荐用 template。

拷贝模块2

探讨 copy 模块的高级用法，如权限管理、备份。

太好了！现在我们进入 copy 模块的 进阶用法阶段（高级应用篇），这部分内容适合你在项目中真正实战、精细控制文件分发。

---

🎯 一、核心能力复习

copy 模块 = 把控制节点的文件 → 远程主机上，附带：权限、备份、校验等控制。

---

🔐 二、高级用法一：权限管理（权限 = owner + group + mode）

你可以通过 owner, group, mode 来确保远程文件的属主/权限严格符合你定义的策略。

- name: 分发数据库配置文件（含权限）
  copy:
    src: ./db.cnf
    dest: /etc/mysql/db.cnf
    owner: mysql
    group: mysql
    mode: '0640'

📌 权限解释：

• '0640' → 所属用户可读写、组可读、其他无权限；

• 引号 ' ' 必须加！否则 YAML 会自动当作八进制数解析出错。

---

🗃️ 三、进阶用法二：自动备份旧文件（backup 参数）

当你对系统中已有文件进行覆盖时，加个 backup: yes，帮你免除手抖的风险！

- name: 拷贝前自动备份原始文件
  copy:
    src: ./secure.conf
    dest: /etc/security/secure.conf
    backup: yes

✅ 效果：

• 如果 /etc/security/secure.conf 已存在，会先备份成：

  /etc/security/secure.conf.2025-05-05@12:34:56~

• 类似自动打快照的效果，很适合在生产环境部署。

---

🔍 四、进阶用法三：只在文件内容发生变化时更新（Ansible 内建）

Ansible 的 copy 模块自带智能判断机制：

✨ 如果目标文件内容和新文件一样，它就不会重复复制，避免多余的 IO 和任务。

这个机制默认开启，无需你配置。

⚙️ 如需强制更新（即使一样也重新拷贝）：

force: yes

---

✅ 五、进阶用法四：只在文件不存在时才复制（小心 force）

force: no

📌 示例：

- name: 只复制一次
  copy:
    src: ./install.sh
    dest: /usr/local/bin/install.sh
    mode: '0755'
    force: no

✨ 场景：分发自定义初始化脚本，只跑一次，不反复覆盖用户手动改过的版本。

---

✅ 六、进阶用法五：校验配置是否可用后再覆盖（validate）

- name: 只在配置语法合法时更新
  copy:
    src: ./nginx.conf
    dest: /etc/nginx/nginx.conf
    validate: "nginx -t -c %s"

📌 %s 会自动替换为目标文件路径。

⚠️ 如果语法不通过，则不会覆盖原文件，这个非常适合对生产配置文件的"保险机制"。

---

📂 七、拷贝整个目录（需配合 with_fileglob 或 loop）

copy 本身不能拷贝目录！若要实现整个目录的复制，建议：

- name: 批量复制一个目录下所有文件
  copy:
    src: "{{ item }}"
    dest: /opt/scripts/
  with_fileglob:
    - ./scripts/*

或者使用更高级的 synchronize 或 template 模块。

---

🎓 八、混合动态变量的进阶技巧（如 per-host 配置）

- name: 每台主机生成个性化欢迎文件
  copy:
    content: "Welcome, this is {{ inventory_hostname }}.\nTime: {{ ansible_date_time.iso8601 }}"
    dest: /etc/welcome.txt
    mode: '0644'

---

🧠 九、总结口诀（进阶版）

owner group mode 保安全，
backup 是你后悔时的保险单，
validate 把错挡在门外，
force: no 保护原汁原味的配置文件！

---

需要我做一个 ✅【权限 + 备份 + 校验 + 文件判断】流程图/示意图？或者你希望我把这些高级用法封装成一个通用模板（可复用的 playbook）？

安装和服务模块

介绍包管理模块（如 yum、apt）和服务管理模块（如 service、systemd）。

非常好！现在我们一起来系统讲解 Ansible 的安装和服务模块，包括：

• 📦 包管理模块（yum, apt）

• 🔧 服务管理模块（service, systemd）

这些模块常用于软件安装、服务启动、开机自启配置，是企业运维中的核心操作。

---

🧭 一、包管理模块：安装/卸载软件包

Ansible 支持多种包管理器，常见的包括：

模块	适用系统	描述
yum	CentOS, RHEL	RedHat 系列通用
dnf	CentOS 8+, Fedora	yum 的升级版
apt	Debian, Ubuntu	Debian 系列
package	所有支持系统	通用封装模块，自动选择

---

✅ 示例 1：使用 yum 安装 nginx

- name: 安装 nginx
  hosts: web
  tasks:
    - name: 使用 yum 安装 nginx
      yum:
        name: nginx
        state: present

参数	说明
name	要安装的软件包名
state	present（安装），absent（卸载），latest（更新）

---

✅ 示例 2：使用 apt 安装 curl

- name: 安装 curl
  hosts: ubuntu
  tasks:
    - name: apt 安装 curl
      apt:
        name: curl
        state: present
        update_cache: yes

update_cache: yes 相当于 apt update，会先更新软件源。

---

✅ 示例 3：使用 package 模块通用方式

- name: 通用方式安装 rsync
  hosts: all
  tasks:
    - name: 安装 rsync（支持 yum/apt 自动适配）
      package:
        name: rsync
        state: present

📌 适合跨平台部署脚本，不用判断系统类型。

---

🔧 二、服务管理模块：管理系统服务

用于启动、停止、重启服务，设置服务是否随系统启动。

模块选择：

模块	适用系统	特点
service	所有系统	通用但较旧
systemd	使用 systemd 的系统	推荐使用，功能更强

---

✅ 示例 1：使用 service 启动 nginx

- name: 启动 nginx 服务
  hosts: web
  tasks:
    - name: 使用 service 启动 nginx
      service:
        name: nginx
        state: started
        enabled: yes

参数	说明
state	started、stopped、restarted
enabled	yes/no，表示是否设置为开机自启

---

✅ 示例 2：使用 systemd 重启 nginx

- name: 重启 nginx
  hosts: web
  tasks:
    - name: 使用 systemd 重启 nginx
      systemd:
        name: nginx
        state: restarted
        enabled: yes
        daemon_reload: yes

参数	含义
daemon_reload	如果你修改了 unit 文件，需要重新加载 systemd 配置

---

🧩 三、结合使用示例：一键部署 Nginx 服务

- name: 一键部署 nginx 服务
  hosts: web
  become: yes
  tasks:
    - name: 安装 nginx
      package:
        name: nginx
        state: present

    - name: 启动 nginx 并设置开机启动
      systemd:
        name: nginx
        state: started
        enabled: yes

---

🎓 总结口诀（中英文结合）

"包管理负责装，服务管理让它跑。"
package/yum/apt 安装，systemd/service 启动守护进程！

用户模块

对用户的增删改查，密码操作，修改用户属性等任务。

明白了！让我们重新整理一下内容，像教科书 一样 系统地 、详细地 讲解 Ansible 用户模块 的增、删、改、查操作。接下来，我将会详细讲解 每个模块的命令行（Ad-Hoc） 和 Playbook（YAML） 使用方法，按照步骤清晰、逻辑连贯的方式展示。

1. 用户模块概述

user 模块在 Ansible 中用于管理系统用户，包括用户的增、删、改、查等操作。它可以创建、删除用户、设置密码、配置组、修改用户属性等。

---

2. 创建用户（Add User）

功能

创建新用户。可以指定用户的状态（存在或不存在），并可以配置其默认 shell、用户组等。

命令行（Ad-Hoc）使用

ansible all -m user -a "name=devops state=present"

• name=devops：指定用户名为 devops。

• state=present：指定用户状态为存在。如果该用户不存在，则会创建此用户。

Playbook 使用

- name: 创建 devops 用户
  hosts: all
  tasks:
    - name: 创建 devops 用户
      user:
        name: devops
        state: present

• name: devops：指定用户名。

• state: present：确保该用户存在。

---

3. 删除用户（Delete User）

功能

删除用户，如果需要，删除该用户的家目录。

命令行（Ad-Hoc）使用

ansible all -m user -a "name=devops state=absent remove=yes"

• state=absent：指定用户状态为不存在，将会删除该用户。

• remove=yes：删除该用户的家目录。

Playbook 使用

- name: 删除 devops 用户（含家目录）
  hosts: all
  tasks:
    - name: 删除 devops 用户
      user:
        name: devops
        state: absent
        remove: yes

• remove: yes：删除用户的家目录。

---

4. 修改用户密码（Modify Password）

功能

为用户设置新密码。密码需要通过哈希加密存储。

命令行（Ad-Hoc）使用

1. 先生成加密密码（可以使用 Python 脚本生成）：

   python3 -c "import crypt; print(crypt.crypt('123456', crypt.mksalt(crypt.METHOD_SHA512)))"

假设返回的结果是：$6$xxxxx$xxxxx...

1. 使用命令行设置密码：

   ansible all -m user -a "name=devops password='6xxxxx$xxxxx...'"

• password='$6$xxxxx$xxxxx...'：设置用户的密码为加密后的值。

Playbook 使用

- name: 设置 devops 用户密码
  hosts: all
  tasks:
    - name: 设置密码
      user:
        name: devops
        password: "{{ '123456' | password_hash('sha512') }}"

• password: "{``{ '123456' | password_hash('sha512') }}"：使用 Ansible Jinja2 过滤器生成加密密码。

---

5. 修改用户属性（Modify User Attributes）

功能

修改用户的属性，如默认 shell、用户组、锁定账户等。

修改用户默认 Shell

命令行（Ad-Hoc）使用

ansible all -m user -a "name=devops shell=/bin/zsh"

• shell=/bin/zsh：将用户 devops 的默认 shell 设置为 /bin/zsh。

Playbook 使用

- name: 修改 devops 用户的默认 shell
  hosts: all
  tasks:
    - name: 设置 shell 为 zsh
      user:
        name: devops
        shell: /bin/zsh

修改用户组

命令行（Ad-Hoc）使用

ansible all -m user -a "name=devops groups=sudo,docker append=yes"

• groups=sudo,docker：将 devops 用户添加到 sudo 和 docker 组中。

• append=yes：如果用户已经在某个组中，保持原有的组。

Playbook 使用

- name: 添加 devops 到多个组
  hosts: all
  tasks:
    - name: 添加到 sudo 和 docker 组
      user:
        name: devops
        groups: sudo,docker
        append: yes

锁定/解锁用户账户

命令行（Ad-Hoc）使用

# 锁定用户
ansible all -m user -a "name=devops password_lock=yes"

# 解锁用户
ansible all -m user -a "name=devops password_lock=no"

• password_lock=yes：锁定用户 devops 账户。

• password_lock=no：解锁用户 devops 账户。

Playbook 使用

- name: 锁定 devops 用户
  hosts: all
  tasks:
    - name: 锁定用户
      user:
        name: devops
        password_lock: yes

---

6. 检查用户是否存在（Check User）

功能

检查用户是否存在于系统中。

命令行（Ad-Hoc）使用

ansible all -m shell -a "getent passwd devops"

• getent passwd devops：检查系统中是否存在名为 devops 的用户。如果用户存在，返回该用户的相关信息。

Playbook 使用

- name: 检查 devops 用户是否存在
  hosts: all
  tasks:
    - name: 获取 devops 用户信息
      shell: getent passwd devops
      register: user_check
    - debug:
        var: user_check.stdout

• getent passwd devops：用 shell 模块检查用户是否存在。

• register: user_check：将返回结果存储到 user_check 变量中。

• debug: var: user_check.stdout：输出用户是否存在的信息。

---

7. 总结

操作类型	命令行（Ad-Hoc）	Playbook 示例
创建用户	ansible all -m user -a "name=devops state=present"	user: name: devops state: present
删除用户	ansible all -m user -a "name=devops state=absent remove=yes"	user: name: devops state: absent remove: yes
设置密码	ansible all -m user -a "name=devops password='$6$xxxxx$xxxxx...'"	`user: name: devops password: "{{ '123456'
修改属性	ansible all -m user -a "name=devops shell=/bin/zsh"	user: name: devops shell: /bin/zsh
锁定账户	ansible all -m user -a "name=devops password_lock=yes"	user: name: devops password_lock: yes
检查用户	ansible all -m shell -a "getent passwd devops"	shell: getent passwd devops

cron模块

讲解 cron 模块，用于自动化配置定时任务。

当你使用 Ansible 配置 定时任务 时，不仅仅是写代码，还是一种享受自动化带来便捷的艺术。🎨 使用 cron 模块，你能够让你的服务器在不需要你亲自干预的情况下完成重复的任务。生活就是要轻松嘛！💪

---

1. Cron 模块概述 - Setting Up the Fun!

cron 模块允许你管理系统的 定时任务，比如在每天的某个时间自动备份，或者在每周的某一天执行系统清理。想象一下，你早上醒来，所有任务都已经按时完成，生活无比轻松。这就是我们追求的目标！😎

---

2. Cron 模块的常用参数 - Your Cron Toolbox 🧰

这些参数就是你定制任务的"工具"，用得好，事半功倍。每个参数都能让你控制任务执行的时间、用户和执行的命令。

参数	说明
name	任务名称，想个有趣的名字吧，反正都是自动化执行！
minute	任务执行的分钟，0-59。
hour	任务执行的小时，0-23。
day	任务执行的天，1-31。
month	任务执行的月，1-12。
weekday	任务执行的星期，0-6。
job	执行的命令，给任务添加实际操作。
user	指定任务的执行用户。
state	present（任务存在）或者 absent（任务不存在）。
special_time	配置特殊的执行时间，如重启时。

---

3. 创建定时任务 - Automating Like a Pro 🚀

命令行示例

想要每天中午12点执行备份任务？只需一条命令，轻松搞定！

ansible all -m cron -a "name='Backup' minute=0 hour=12 job='/usr/bin/backup.sh' user=user1"

这就像设置闹钟一样简单，12点任务准时开启，让你自由享受下午茶时间！☕️

---

Playbook 示例

如果你喜欢写 Playbook，那你就是自动化编程的高手啦！我们来试试用 Playbook 配置这个任务：

- name: 配置定时备份任务
  hosts: all
  tasks:
    - name: 添加每日备份任务
      cron:
        name: "Backup"
        minute: "0"
        hour: "12"
        job: "/usr/bin/backup.sh"
        user: "user1"
        state: present

Playbook 就像是给自动化生活的脚本，简单易懂而又强大！🎉

---

4. 删除定时任务 - Bye-Bye Tasks 👋

你可能设置了一些临时的定时任务，现在想要删掉它们。没问题，使用 state: absent 就能轻松删除。

命令行示例

ansible all -m cron -a "name='Backup' state=absent"

每次删除任务，就像减掉负担，心情也变得更轻松！😌

---

Playbook 示例

- name: 删除备份任务
  hosts: all
  tasks:
    - name: 删除定时备份任务
      cron:
        name: "Backup"
        state: absent

删除任务时，没负担，工作效率也能提升！💼

---

5. 特殊时间任务 - The Magic of reboot and More ✨

有时你可能希望在 重启时 执行某个任务，或者设置每天的某个固定时间自动执行。cron 模块支持这些"魔法时刻"！🪄

命令行示例

ansible all -m cron -a "name='Reboot Task' special_time=reboot job='/usr/bin/cleanup.sh'"

这个任务将在系统重启时执行，完全不用担心每次重启后忘记清理系统！⚡️

---

Playbook 示例

- name: 配置重启时执行的清理任务
  hosts: all
  tasks:
    - name: 设置重启时执行清理脚本
      cron:
        name: "Reboot Task"
        special_time: reboot
        job: "/usr/bin/cleanup.sh"
        state: present

重启时执行任务，真是省心又省力！🔧

---

6. 通过环境变量执行任务 - Adding Some Flavor 🌶️

有时你希望任务执行时设置一些环境变量？Ansible 也能搞定！可以用 environment 来给任务设置必要的环境参数。

Playbook 示例

- name: 配置带环境变量的定时任务
  hosts: all
  tasks:
    - name: 设置每日备份任务并添加环境变量
      cron:
        name: "Backup with env"
        minute: "0"
        hour: "2"
        job: "/usr/bin/backup.sh"
        user: "user1"
        environment:
          BACKUP_DIR: "/mnt/backups"
          LOG_LEVEL: "info"
        state: present

有了环境变量，任务更加灵活和定制化！让你可以根据需求自定义任务的执行环境，甚至在备份中记录日志，带来更多的控制权！📜

---

7. Cron 时间格式 - The Magic Behind Scheduling ⏰

以下是 Cron 时间格式的简要解释，你可以根据这些来精确控制任务的执行时间，完全不用担心时间冲突！

字段	允许值	说明
分钟	0-59	每小时的分钟
小时	0-23	每天的小时
日	1-31	月中的哪一天
月	1-12 或 jan-dec	年中的哪个月
星期	0-6 或 sun-sat	一周的哪一天，0 表示星期天

常见的时间表达式：

• *：所有可能的值（例如 * * * * * 表示每分钟执行一次）。

• */5：每5个单位执行一次（例如 */5 * * * * 表示每5分钟执行一次）。

• 1-5：范围（例如 1-5 * * * * 表示每月的 1 到 5 日执行）。

• 1,3,5：多个值（例如 1,3,5 * * * * 表示每月的 1、3、5 日执行）。

---

8. 总结 - Keep Automating, Keep Enjoying! 😄

使用 Ansible 配置 Cron 定时任务 是让你的服务器自动化管理的绝佳方式！通过灵活的时间设置、任务管理和环境配置，你可以让日常任务完全自动化，解放自己的双手，让生活变得更加轻松愉快！

从此以后，定时任务再也不需要手动操作，交给 Ansible，让自动化和你一起享受每一天！🎉

如果你有任何问题或者希望了解更多高级用法，记得随时找我！我们一起享受自动化的乐趣吧！🚀

shell模块

介绍 shell 模块，执行自定义 Shell 命令及适用场景。

想象一下，你的服务器正在为你执行一条自定义的 Shell 命令 ，自动化的神奇感让你倍感轻松。Ansible 的 shell 模块就是为这种场景而生！无论是执行系统命令、启动服务，还是进行复杂的文件处理，shell 模块都能让你如鱼得水。🌊

---

1. Shell 模块概述 - Automating Commands with Style 🚀

Ansible 的 shell 模块允许你在远程主机上执行任何自定义的 Shell 命令，就像你直接登录到服务器上输入命令一样。它支持复杂的命令行操作，甚至是管道和重定向操作。

适用场景：

• 执行系统级命令（如创建目录、删除文件、安装软件等）。

• 运行多个命令并使用管道、重定向、条件语句等。

• 自动化传统 shell 脚本任务。

• 执行在目标机器上未安装的工具时，使用临时 shell 命令。

小提示：虽然 shell 模块非常强大，但有时 command 模块 会更适合某些任务，因为 command 模块不依赖于 shell 的环境，执行时更加安全。💡

---

2. Shell 模块的常用参数 - Your Command Toolbox 🧰

以下是 shell 模块的常见参数，掌握它们让你能更加高效地管理和执行命令。

参数	说明
cmd	要执行的 Shell 命令。
chdir	设置命令执行前的工作目录。
creates	如果指定的文件存在，任务将被跳过。
removes	如果指定的文件不存在，任务将被跳过。
executable	指定一个特定的 shell 来执行命令。
warn	是否显示警告信息（默认为 yes）。
stdin	从标准输入传递给命令的内容。

---

3. 执行自定义 Shell 命令 - Let's Run Some Code! 💻

你可以像在终端中输入命令一样，通过 shell 模块在远程主机上运行自定义命令。

命令行示例

假设你想在远程主机上创建一个目录并打印日志文件，可以使用如下命令：

ansible all -m shell -a "mkdir -p /tmp/test && echo 'Directory created' >> /tmp/test.log"

这个命令在目标主机上创建 /tmp/test 目录，并将一条日志信息写入 /tmp/test.log 文件。这样，你的自动化任务就能在几秒钟内完成！⚡

---

Playbook 示例

如果你更喜欢使用 Playbook 来组织任务，我们也可以通过以下方式来执行相同的命令：

- name: 创建目录并记录日志
  hosts: all
  tasks:
    - name: 创建目录并写入日志
      shell: "mkdir -p /tmp/test && echo 'Directory created' >> /tmp/test.log"

使用 Playbook，你的任务更加结构化，适合进行复杂的自动化流程！📂

---

4. 执行带管道和重定向的命令 - Making It Fancy 💫

Shell 脚本最强大的地方之一就是管道（|）和重定向（>）操作。shell 模块完全支持这些操作，让你能够组合多个命令。

命令行示例

假设你想列出一个目录下的文件，并将输出结果保存到一个文件中：

ansible all -m shell -a "ls -l /tmp | grep test > /tmp/test_files.txt"

这里，我们列出 /tmp 目录下的文件，筛选包含 test 的行，并将结果保存到 /tmp/test_files.txt 文件中。

---

Playbook 示例

- name: 列出目录并保存到文件
  hosts: all
  tasks:
    - name: 列出目录文件并筛选
      shell: "ls -l /tmp | grep test > /tmp/test_files.txt"

通过 shell 模块，结合管道和重定向，你可以轻松地处理和存储任务输出，提供更多的灵活性！📦

---

5. 工作目录和文件检查 - Automating with Precaution ⚠️

有时，你需要确保命令在特定目录下执行，或者在执行前检查某些文件是否已经存在。

命令行示例

假设你希望在 /tmp/test 目录下执行一个命令，并在文件 /tmp/test.log 存在时跳过任务：

ansible all -m shell -a "cd /tmp/test && echo 'Task Executed' >> /tmp/test.log" 
  creates="/tmp/test.log"

这个命令会在 /tmp/test 目录下执行，且只有在 /tmp/test.log 文件不存在时才会执行任务。

---

Playbook 示例

- name: 确保命令在正确的目录执行
  hosts: all
  tasks:
    - name: 在特定目录下执行命令
      shell: "cd /tmp/test && echo 'Task Executed' >> /tmp/test.log"
      creates: "/tmp/test.log"

通过 creates 参数，你可以避免重复执行任务，节省时间和资源。🔄

---

6. 设置环境变量 - Customizing the Shell 🧑‍💻

你可能需要为某个任务设置特定的环境变量，shell 模块也支持这一功能。

Playbook 示例

- name: 执行带环境变量的命令
  hosts: all
  tasks:
    - name: 设置环境变量并执行命令
      shell: "echo $MY_VAR"
      environment:
        MY_VAR: "Hello, Ansible!"

这里，我们设置了一个环境变量 MY_VAR 并在远程主机上执行命令来输出它的值。

通过设置环境变量，你可以让任务执行时根据需要改变环境配置！🌍

---

7. 总结 - Shell Your Way to Automation! 🎉

使用 Ansible 的 shell 模块，你不仅可以轻松执行系统级命令，还能将复杂的任务自动化、管理和调度。你只需要简单的命令行或者 Playbook，就可以让远程主机执行几乎所有的 shell 操作。

小贴士：

• command 模块 ：如果你不需要使用 shell 特性（如管道、重定向），建议使用 command 模块，它更安全。

• shell 模块：适用于需要复杂命令、条件语句、管道和重定向的场景。

所以，尽情享受自动化带来的便利吧！让 Ansible 的 shell 模块 成为你工作流程的一部分，自动化所有你能想到的任务，剩下的时间就可以用来喝杯咖啡，放松心情！☕️

如果有任何疑问或更复杂的需求，随时告诉我，我们一起探索更多的自动化世界！🌟

YAML语言

详细讲解 YAML 语法，Ansible Playbook 的核心语言，涵盖结构、变量、循环。

YAML 是一种简洁且易于读写的数据序列化格式，广泛用于配置文件和数据交换。对于 Ansible 来说，YAML 是 Playbook 的核心语言。在 Ansible 中，Playbook 是用于定义自动化任务的文件，格式就是 YAML。

让我们深入了解 YAML 的语法，并看看它如何在 Ansible Playbook 中工作！🔧

---

1. YAML 语法基础 - What is YAML? 🧐

YAML（Y et A nother M arkup L anguage）是一种比 XML 和 JSON 更简洁、易读的格式，常用于配置文件。YAML 的设计目标是将数据表达得更加直观和人类友好。它通过 缩进 来表示层次结构，这使得它特别适合表示配置数据、清单或其他结构化数据。

基本语法结构：

• 缩进 ：YAML 使用空格缩进，不可使用 tab 键，每层缩进通常使用 2 个空格。

• 键值对：YAML 的基本单位是键值对，键与值之间用冒号分隔，键和值之间必须有至少一个空格。

  key: value

• 列表 ：通过短横线（-）表示，列表项通常缩进 2 个空格。

  fruits:
  - apple
  - banana
  - orange

• 字典：字典中的键值对通过缩进和冒号来表示。

  person:
  name: John
  age: 30

• 多行字符串 ：可以使用 |（保留换行符）或 >（折叠换行符）来处理多行文本。

  description: |
  This is a multiline string.
  Each new line is retained.

  summary: >
  This is a multiline string.
  It will be folded into a single line.

---

2. Ansible Playbook 中的 YAML 结构

Ansible Playbook 由 Play 和 Tasks 组成。一个 Playbook 通常包含多个 Play，每个 Play 是一个针对特定主机组执行任务的集合。

Playbook 的结构：

- name: Playbook 例子
  hosts: all
  tasks:
    - name: 任务1
      action: args
    - name: 任务2
      action: args

• name：Play 或任务的名称，用于描述这个 Play 或任务的目的。

• hosts ：指定 Play 应该作用的主机组，可以是 all、localhost 或其他定义的组。

• tasks：在该 Play 中要执行的任务列表，每个任务通常是一个模块。

---

3. Playbook 中的变量 - Flexible and Dynamic 💡

在 Playbook 中，变量使得配置更加动态和灵活。变量可以在多个地方定义，如在 inventory 文件、Playbook 内部、或 Ansible 运行时通过命令行传递。

定义变量：

变量通常是键值对的形式，可以通过 vars 关键字定义：

- name: Playbook with variables
  hosts: all
  vars:
    user: 'admin'
    path: '/home/admin'
  tasks:
    - name: Create a directory
      file:
        path: "{{ path }}"
        state: directory

在这个例子中，path 和 user 是变量，可以在 Playbook 的任何地方使用。

• 变量使用 {``{ }} 来引用。比如 {``{ path }} 会被替换成 /home/admin。

从外部文件加载变量：

你也可以通过 vars_files 引入外部 YAML 文件中的变量。

- name: Playbook with external variables
  hosts: all
  vars_files:
    - vars.yml
  tasks:
    - name: Print the user variable
      debug:
        msg: "User is {{ user }}"

vars.yml:

user: "admin"
path: "/home/admin"

---

4. Playbook 中的循环 - Automate Repeated Tasks 🔄

循环在自动化过程中非常有用，尤其是当你需要对多个目标执行相似操作时。Ansible 提供了几种循环结构，包括 loop 和 with_items 等。

使用 loop 执行循环：

- name: Install packages
  hosts: all
  tasks:
    - name: Install each package
      apt:
        name: "{{ item }}"
        state: present
      loop:
        - nginx
        - vim
        - git

这个任务会依次在目标主机上安装 nginx、vim 和 git，简洁而高效。

使用 with_items 循环（早期版本）：

with_items 是另一种循环的方式，适用于早期的 Ansible 版本：

- name: Install packages with with_items
  hosts: all
  tasks:
    - name: Install each package
      apt:
        name: "{{ item }}"
        state: present
      with_items:
        - nginx
        - vim
        - git

虽然 loop 是目前推荐的方式，但 with_items 依然广泛使用。

---

5. 处理条件语句 - Control Flow ⚙️

条件语句在自动化任务中也非常重要，能够根据条件执行不同的操作。使用 when 关键字可以对任务添加条件。

使用 when 进行条件判断：

- name: Install package only if needed
  hosts: all
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present
      when: ansible_facts.os_family == "Debian"

这个任务仅在目标主机的操作系统是 Debian 系列时才会执行。

---

6. Playbook 示例 - 综合应用 📝

让我们把这些元素结合起来，做一个实际的 Playbook 示例，展示如何使用变量、循环、条件判断和其他基本元素：

- name: Configure servers
  hosts: all
  vars:
    packages:
      - nginx
      - vim
      - git
    server_name: "webserver"
  tasks:
    - name: Install necessary packages
      apt:
        name: "{{ item }}"
        state: present
      loop: "{{ packages }}"
    
    - name: Configure nginx
      template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
      when: ansible_facts.os_family == "Debian"
    
    - name: Ensure nginx is running
      service:
        name: nginx
        state: started
        enabled: yes

解释：

• 变量 ：我们在 vars 部分定义了 packages 和 server_name 变量。

• 循环 ：我们用 loop 来循环安装多个软件包。

• 条件 ：when 语句确保只有在操作系统是 Debian 时才配置 nginx。

• 任务 ：我们定义了多个任务，使用 apt 安装软件包，使用 template 管理配置文件，使用 service 确保 nginx 启动。

---

7. 总结 - Mastering YAML and Playbooks 📚

YAML 是 Ansible Playbook 的基础语法，掌握它将帮助你编写更加简洁、高效且易于维护的自动化脚本。通过变量、循环、条件和文件结构的组合，你可以灵活地管理和自动化大规模的配置任务。

总结要点：

• 缩进和格式：YAML 强调缩进，使用空格而非 tab 键。

• 变量和引用 ：使用 {``{ variable_name }} 来引用变量。

• 循环和条件 ：使用 loop 和 when 来增加自动化的灵活性。

• Playbook：用 YAML 编写的 Playbook 是 Ansible 的核心，通过定义任务、主机和变量来管理自动化任务。

掌握这些基础，你就能快速高效地创建强大的自动化任务，解放自己的双手！让我们一起用 Ansible 来自动化工作，享受更多的时间来做自己喜欢的事情吧！🎉

文件模块

对文件及其目录进行各种操作。

Ansible 提供了许多模块来帮助你管理文件和目录，file 模块是其中最常用的模块之一，它用于设置文件的属性（如权限、拥有者、状态等）。同时，Ansible 还提供了其他文件相关的模块，例如 copy 、template 、fetch 、lineinfile 等，用于不同场景下的文件操作。

1. file 模块概述 - 基础文件管理 🗂️

file 模块用于管理文件的权限、拥有者、组以及文件的存在状态。你可以创建、删除、修改文件权限和所有者信息等。

常见参数：

• path：要操作的文件或目录的路径。

• state ：文件或目录的状态。常见值有 file（普通文件）、directory（目录）、absent（删除文件或目录）和 touch（创建空文件）。

• owner：文件的所有者。

• group：文件的所属组。

• mode ：文件的权限设置（如 0644 或 u+x）。

• recurse：递归应用权限和所有者设置（适用于目录）。

基本用法：

- name: Set file permissions and ownership
  hosts: all
  tasks:
    - name: Ensure the file exists and has correct permissions
      file:
        path: /tmp/myfile.txt
        state: file
        owner: root
        group: root
        mode: '0644'

• state: file 表示目标是一个普通文件。

• mode: '0644' 设置文件的权限为 rw-r--r--。

• owner 和 group 用于设置文件的所有者和所属组。

---

2. 创建目录 - state: directory 🚀

如果你需要创建一个目录并设置相关权限，file 模块也可以做到。

- name: Ensure the directory exists
  hosts: all
  tasks:
    - name: Create a directory with proper permissions
      file:
        path: /tmp/mydirectory
        state: directory
        owner: root
        group: root
        mode: '0755'

• state: directory 用于确保目标路径是一个目录，并且会在目录不存在时自动创建它。

• mode: '0755' 为目录设置权限，rwxr-xr-x。

---

3. 删除文件或目录 - state: absent 🗑️

如果你需要删除一个文件或目录，可以使用 state: absent。

- name: Remove a file
  hosts: all
  tasks:
    - name: Remove the file if it exists
      file:
        path: /tmp/myfile.txt
        state: absent

• state: absent 会确保目标路径的文件或目录被删除。

---

4. 创建空文件 - state: touch 📝

如果你想要确保某个文件存在，并且该文件内容为空，可以使用 state: touch。

- name: Create an empty file
  hosts: all
  tasks:
    - name: Touch a file
      file:
        path: /tmp/myemptyfile.txt
        state: touch

• state: touch 会创建一个空文件，如果文件已经存在，则更新文件的时间戳。

---

5. 递归操作 - recurse 选项 🔄

在目录中设置文件权限和所有者时，recurse 选项非常有用，它会递归地应用这些设置到目录中的所有文件和子目录。

- name: Recursively set ownership for a directory
  hosts: all
  tasks:
    - name: Set ownership recursively for directory
      file:
        path: /tmp/mydirectory
        state: directory
        owner: root
        group: root
        recurse: yes

• recurse: yes 确保目录中所有的文件和子目录都应用相同的权限和拥有者设置。

---

6. 其他常用模块 - 扩展文件管理功能 🔍

除了 file 模块，Ansible 还提供了其他用于文件管理的模块，这些模块针对不同的需求提供了额外的功能。

copy 模块 - 用于复制文件或目录到远程主机。

- name: Copy a file to remote host
  hosts: all
  tasks:
    - name: Copy a file
      copy:
        src: /local/path/to/file
        dest: /remote/path/to/file
        owner: root
        group: root
        mode: '0644'

template 模块 - 用于将 Jinja2 模板文件渲染到远程主机。

- name: Template a file on remote host
  hosts: all
  tasks:
    - name: Create a config file using a template
      template:
        src: /local/path/to/template.j2
        dest: /remote/path/to/config.conf
        owner: root
        group: root
        mode: '0644'

lineinfile 模块 - 用于编辑文件中的特定行。

- name: Ensure a line is present in a file
  hosts: all
  tasks:
    - name: Add a line to a file if not present
      lineinfile:
        path: /tmp/myfile.txt
        line: "New line to add"

fetch 模块 - 从远程主机获取文件。

- name: Fetch a file from remote host
  hosts: all
  tasks:
    - name: Fetch the file
      fetch:
        src: /remote/path/to/file
        dest: /local/path/to/store/file

---

7. 综合示例 - 综合运用 file 模块

- name: Manage files and directories
  hosts: all
  tasks:
    - name: Create a directory if it doesn't exist
      file:
        path: /tmp/mydir
        state: directory
        owner: root
        group: root
        mode: '0755'

    - name: Set permissions on a file
      file:
        path: /tmp/myfile.txt
        state: file
        owner: user
        group: group
        mode: '0644'

    - name: Delete a file if it's present
      file:
        path: /tmp/oldfile.txt
        state: absent

    - name: Touch a file (create it if it doesn't exist)
      file:
        path: /tmp/emptyfile.txt
        state: touch

    - name: Recursively change ownership of directory
      file:
        path: /tmp/mydir
        state: directory
        owner: user
        group: group
        recurse: yes

总结 - File Module 🌟

file 模块是 Ansible 中非常强大的工具，能够帮助你管理文件和目录的状态、权限、所有者等属性。它与其他模块如 copy、template、lineinfile 等配合使用时，能够大大提高文件管理的效率和自动化程度。掌握它，让你的自动化管理更加高效！

收集模块

收集主机相关信息。

Ansible 提供了多个模块来收集目标主机的各种信息，以便在自动化任务中进行进一步处理。这些信息可以包括操作系统版本、网络配置、硬件信息等。最常用的收集信息的模块是 setup 模块，它可以收集系统的各种细节，并将这些信息返回给 Ansible playbook 进行后续操作。

1. setup 模块概述 - 系统信息收集 🔍

setup 模块是 Ansible 提供的一个非常强大的模块，用于收集目标主机的事实信息（Facts）。这些信息包括但不限于：

• 主机的操作系统信息（如版本、架构）

• 内存、CPU、磁盘等硬件信息

• 网络配置（如 IP 地址、主机名、DNS 配置）

• Python 版本和路径

• 系统用户和组信息

常见参数：

• filter：指定你想要收集的特定事实。你可以使用这个选项来收集特定的信息。

• gather_subset ：决定收集哪些事实。常见值有 all（收集所有信息）、minimal（最少信息）、hardware（硬件相关信息）等。

• gathering ：设置收集信息的级别，常用的有 smart（默认，智能收集）和 explicit（明确要求收集）。

基本用法：

- name: Gather system facts
  hosts: all
  tasks:
    - name: Collect system information
      setup:

这个基本的任务会收集所有目标主机的系统信息。

---

2. 收集特定信息 - 使用 filter 参数 🧩

如果你只想收集某些特定的系统信息，可以使用 filter 参数。比如，你只关心主机的 IP 地址或操作系统信息。

- name: Gather specific facts
  hosts: all
  tasks:
    - name: Collect only network and OS info
      setup:
        filter:
          - ansible_all_ipv4_addresses
          - ansible_distribution
          - ansible_distribution_version

• filter 选项可以指定你需要的具体信息。比如，ansible_all_ipv4_addresses 返回 IPv4 地址，ansible_distribution 和 ansible_distribution_version 返回操作系统的信息。

---

3. 限制收集信息的范围 - 使用 gather_subset 参数 🚪

你还可以使用 gather_subset 参数来限制收集的信息范围。这可以帮助加速收集过程，特别是在你只对某一类信息感兴趣时。

- name: Gather minimal system facts
  hosts: all
  tasks:
    - name: Collect only minimal system facts
      setup:
        gather_subset:
          - minimal

• gather_subset 选项的常见值有：

  • all：收集所有系统信息（默认）。

  • minimal：只收集最基本的信息。

  • hardware：收集硬件信息（如 CPU、内存、磁盘等）。

  • network：只收集网络相关的信息。

---

4. 使用收集的信息 - 变量访问 🎯

收集到的信息会以变量的形式存储在 Ansible 的 facts 中，之后你可以直接引用这些变量来进行任务处理。例如，你可以使用收集到的操作系统版本来决定是否安装某个特定的包。

- name: Use gathered facts
  hosts: all
  tasks:
    - name: Display the OS version
      debug:
        msg: "The operating system is {{ ansible_distribution }} {{ ansible_distribution_version }}"

    - name: Display IPv4 address
      debug:
        msg: "The host's IP address is {{ ansible_all_ipv4_addresses }}"

• {``{ ansible_distribution }}：操作系统的发行版（如 Ubuntu、CentOS）。

• {``{ ansible_distribution_version }}：操作系统的版本号。

• {``{ ansible_all_ipv4_addresses }}：所有的 IPv4 地址。

---

5. 收集自定义信息 - set_fact 模块 🔧

除了使用 setup 模块自动收集主机信息外，你还可以通过 set_fact 模块自定义设置变量，将某些信息存储为自定义变量，以便后续使用。

- name: Set custom facts
  hosts: all
  tasks:
    - name: Set a custom fact
      set_fact:
        custom_var: "This is a custom fact"

    - name: Display the custom fact
      debug:
        msg: "The custom fact is {{ custom_var }}"

通过 set_fact 模块，你可以创建你自己的事实信息，帮助你管理和组织 Ansible playbook 中的变量。

---

6. 结合 when 语句进行条件操作 🔄

你还可以使用 Ansible 中的 when 语句，根据收集的系统信息来决定是否执行某个任务。

- name: Conditional tasks based on facts
  hosts: all
  tasks:
    - name: Install a package only on Ubuntu systems
      apt:
        name: vim
        state: present
      when: ansible_distribution == "Ubuntu"

    - name: Install a package only on CentOS systems
      yum:
        name: vim
        state: present
      when: ansible_distribution == "CentOS"

在这个例子中，任务根据操作系统的不同选择使用 apt 或 yum 来安装软件包。

---

7. 高级用法 - 使用 gathering: explicit 强制收集信息 📚

有时，默认的智能收集（gathering: smart）可能不会收集所有你需要的信息。在这种情况下，你可以强制 Ansible 在每次执行时都收集事实信息，使用 gathering: explicit 来显式收集。

- name: Explicitly gather facts
  hosts: all
  gather_facts: yes
  tasks:
    - name: Collect facts explicitly
      setup:
        gathering: explicit

---

8. 综合示例 - 完整的 setup 模块应用 ⚙️

- name: Gather and use system facts
  hosts: all
  tasks:
    - name: Collect all facts
      setup:

    - name: Display OS information
      debug:
        msg: "The operating system is {{ ansible_distribution }} {{ ansible_distribution_version }}"

    - name: Display system architecture
      debug:
        msg: "The architecture is {{ ansible_architecture }}"

    - name: Display all IPv4 addresses
      debug:
        msg: "The host's IPv4 addresses are {{ ansible_all_ipv4_addresses }}"

总结 - 收集模块的重要性 🌟

setup 模块是 Ansible 中非常重要的一个工具，能够帮助你收集关于目标主机的详细信息。通过这些信息，你可以在 Playbook 中实现更智能、更灵活的操作，针对不同的主机条件做出动态决策。掌握 setup 模块的使用，不仅能够加快你的自动化部署，还能让你更好地了解目标主机的状态。

fetch模块

从远程主机获取文件到本地。

Ansible 提供了 fetch 模块，允许你从远程主机拉取文件到本地。这对于将日志文件、配置文件或其他文件从远程系统收集到本地非常有用，尤其在进行故障排查、日志分析或者备份任务时，fetch 模块表现得尤为重要。

1. fetch 模块概述 - 拉取远程文件 📥

fetch 模块可以将远程主机上的文件复制到 Ansible 控制节点的本地目录。你可以选择是否保留文件的权限和所有者信息，甚至可以递归拉取目录中的所有文件。

常见参数：

• src：远程主机上的文件路径。

• dest：本地保存文件的路径。

• flat ：如果为 yes，则所有从远程主机获取的文件将存储在 dest 目录下的同一平级目录中，而不是保留其原始的文件夹结构。

• validate ：对文件进行验证，支持像 sha256sum 等校验和命令。

• failsafe ：如果为 yes，则当远程文件不存在时，任务会忽略并继续执行，而不是失败。

---

2. 基本用法 - 拉取单个文件 📂

最简单的用法是将远程主机上的单个文件拉取到本地。

- name: Fetch a file from remote host
  hosts: all
  tasks:
    - name: Fetch the log file from the remote server
      fetch:
        src: /var/log/syslog
        dest: /tmp/remote_logs/

• src: /var/log/syslog：远程主机上的文件路径。

• dest: /tmp/remote_logs/：将文件保存到本地的路径。文件会根据远程路径结构自动组织。

---

3. 拉取文件并保留目录结构 - 默认行为 🏗️

默认情况下，fetch 模块会保留远程文件的路径结构。这意味着，如果你从多个主机上拉取文件时，文件会按照原始目录结构保存在本地。

- name: Fetch file and retain directory structure
  hosts: all
  tasks:
    - name: Fetch the config file from remote server
      fetch:
        src: /etc/myapp/config.conf
        dest: /tmp/fetched_configs/

如果有多个主机执行此任务，文件会被保存在本地路径 /tmp/fetched_configs/ 下，并且会自动根据远程路径生成子目录。

---

4. 使用 flat 参数 - 拉取文件并扁平化目录结构 🌍

如果你希望从多个主机拉取的文件不保留目录结构，可以使用 flat: yes 参数。这会把所有文件放在指定的本地目标目录下，而不使用远程路径结构。

- name: Fetch files and flatten directory structure
  hosts: all
  tasks:
    - name: Fetch the config file without directory structure
      fetch:
        src: /etc/myapp/config.conf
        dest: /tmp/fetched_configs/
        flat: yes

• flat: yes 会把所有文件直接保存在 /tmp/fetched_configs/ 目录下，不保留原本的目录结构。

---

5. 拉取目录中的多个文件 - 使用 recursive 选项 🌲

如果你需要拉取一个目录中的所有文件，可以使用 recursive: yes 选项。这个选项会递归地将目标目录下的所有文件都拉取到本地。

- name: Fetch files from a directory recursively
  hosts: all
  tasks:
    - name: Fetch all files from a remote directory
      fetch:
        src: /var/log/myapp/
        dest: /tmp/myapp_logs/
        recursive: yes

• recursive: yes 会确保目录及其所有内容（包括子目录中的文件）都被拉取。

---

6. 验证拉取的文件 - 使用 validate 参数 🔐

如果你想验证拉取的文件是否完整，可以使用 validate 参数，通过校验和工具（如 sha256sum）验证文件的完整性。

- name: Fetch and validate files
  hosts: all
  tasks:
    - name: Fetch the file and validate its checksum
      fetch:
        src: /var/log/myapp.log
        dest: /tmp/myapp_logs/
        validate: sha256sum

• validate: sha256sum 会对下载的文件进行校验，确保文件没有损坏。

---

7. 综合示例 - 从多个主机获取文件 📤

如果你需要从多个主机获取相同的文件，并且将它们保存在本地不同的目录，可以使用以下示例：

- name: Fetch log files from remote hosts
  hosts: all
  tasks:
    - name: Fetch logs from each host
      fetch:
        src: /var/log/syslog
        dest: /tmp/host_logs/
        flat: yes

这会将每个主机的 /var/log/syslog 文件保存在本地 /tmp/host_logs/ 目录中，所有文件会被保存在一个平级目录中（不保留远程路径结构）。

---

8. 处理不存在的文件 - 使用 failsafe 参数 🚨

如果你试图拉取的文件在远程主机上不存在，可以使用 failsafe: yes 参数来避免任务失败，而是跳过该文件。

- name: Fetch file with failsafe enabled
  hosts: all
  tasks:
    - name: Fetch the file, even if it doesn't exist
      fetch:
        src: /path/to/nonexistent/file.log
        dest: /tmp/fetched_files/
        failsafe: yes

• failsafe: yes 会确保即使文件不存在，任务也不会失败，而是跳过该文件。

---

9. 综合示例 - 完整使用 fetch 模块 🔄

- name: Fetch files from remote hosts
  hosts: all
  tasks:
    - name: Fetch a specific file
      fetch:
        src: /var/log/application.log
        dest: /tmp/logs/
        flat: yes

    - name: Fetch a directory recursively
      fetch:
        src: /etc/myapp/
        dest: /tmp/app_configs/
        recursive: yes

    - name: Validate fetched file with sha256sum
      fetch:
        src: /var/log/myapp.log
        dest: /tmp/logs/
        validate: sha256sum

    - name: Skip fetching if file does not exist
      fetch:
        src: /path/to/nonexistent/file.log
        dest: /tmp/logs/
        failsafe: yes

总结 - fetch 模块的重要性 🌟

Ansible 的 fetch 模块为你提供了一种非常简单且高效的方式来从远程主机获取文件到本地。无论是获取单个文件、递归目录，还是验证文件的完整性，它都可以轻松应对。通过与其他模块的结合，fetch 模块可以极大地提升你的自动化任务效率，尤其在日志收集、文件备份和配置管理等场景中非常有用！

group模块

管理用户组。

Ansible 的 group 模块用于管理目标主机上的用户组。它可以帮助你创建、删除、修改用户组，以及确保某些用户组的存在与否。用户组是管理 Linux 系统中用户权限的重要组成部分，group 模块可以让你在自动化配置过程中轻松操作这些用户组。

1. group 模块概述 - 用户组管理 ⚙️

group 模块的主要功能包括：

• 创建用户组

• 删除用户组

• 确保用户组的存在

• 修改用户组的属性（如 GID）

常见参数：

• name：用户组的名称（必需）。

• state：用户组的状态，常见的值有：

  • present：确保用户组存在（默认）。

  • absent：确保用户组不存在。

• gid：指定用户组的 GID（可选）。

• system ：是否为系统组，值为 yes 或 no（默认值是 no）。

• force ：如果为 yes，则在删除组时强制删除相关的文件或目录（适用于 state: absent 时）。

---

2. 基本用法 - 创建用户组 🛠️

最常见的操作是创建一个新的用户组。可以通过设置 state: present 来确保某个用户组存在。

- name: Ensure the "developers" group exists
  hosts: all
  tasks:
    - name: Create the "developers" group
      group:
        name: developers
        state: present

• name: developers：指定要创建的用户组名。

• state: present：确保用户组存在，如果用户组已经存在，Ansible 会跳过此任务。

---

3. 删除用户组 - 使用 state: absent 🔥

如果你需要删除一个用户组，可以通过将 state 设置为 absent 来确保用户组被移除。

- name: Remove the "oldgroup" group
  hosts: all
  tasks:
    - name: Remove the "oldgroup" group
      group:
        name: oldgroup
        state: absent

• state: absent：确保删除指定的用户组。如果该用户组不存在，任务会跳过。

---

4. 设置用户组 GID - 使用 gid 参数 🆔

你可以为用户组指定一个 GID（Group ID），这样可以确保用户组拥有特定的标识符。

- name: Create the "admins" group with a specific GID
  hosts: all
  tasks:
    - name: Create the "admins" group with GID 1001
      group:
        name: admins
        gid: 1001
        state: present

• gid: 1001：设置用户组的 GID 为 1001。

---

5. 创建系统组 - 使用 system 参数 🏷️

如果你希望创建一个系统组（用于系统级别的操作或软件包管理），可以设置 system: yes。系统组通常用于那些不需要登录的系统服务。

- name: Create a system group for application
  hosts: all
  tasks:
    - name: Create the "app" system group
      group:
        name: app
        system: yes
        state: present

• system: yes：创建一个系统组。

---

6. 修改现有用户组 - 使用 name 和 gid 修改属性 ⚡

如果你需要修改现有用户组的 GID 或其他属性，可以通过更新 name 或 gid 参数来修改。

- name: Modify the "staff" group GID
  hosts: all
  tasks:
    - name: Change the GID of the "staff" group
      group:
        name: staff
        gid: 2000
        state: present

• gid: 2000 ：修改现有的 staff 用户组的 GID 为 2000。

---

7. 确保多个用户组存在 - 通过循环批量操作 🔄

如果你需要同时管理多个用户组，可以通过循环的方式来批量创建用户组。

- name: Ensure multiple groups exist
  hosts: all
  tasks:
    - name: Create multiple groups
      group:
        name: "{{ item }}"
        state: present
      loop:
        - admins
        - developers
        - sysops

• loop：用来循环创建多个用户组。

---

8. 综合示例 - 管理用户组 🛠️

- name: Manage groups on remote hosts
  hosts: all
  tasks:
    - name: Ensure "developers" group exists
      group:
        name: developers
        state: present

    - name: Ensure "admins" group exists with GID 1001
      group:
        name: admins
        gid: 1001
        state: present

    - name: Remove "oldgroup" if it exists
      group:
        name: oldgroup
        state: absent

    - name: Create "app" system group
      group:
        name: app
        system: yes
        state: present

总结 - group 模块的重要性 🌟

Ansible 的 group 模块是系统管理员和自动化工程师非常重要的工具，能够帮助我们轻松管理 Linux 系统上的用户组。通过使用该模块，你可以自动化地创建、删除或修改用户组，无需手动执行命令，从而提高效率并减少人为错误。在一些复杂的自动化流程中，管理用户组是实现权限控制、资源隔离等关键任务的基础。

script模块

在指定节点运行服务的的脚本。

Ansible 的 script 模块用于在远程主机上执行本地的脚本文件。你可以通过 script 模块将本地脚本传输到目标节点，并在远程节点上执行。这对于自动化运行一些自定义的 Shell 脚本或其他命令行操作非常有用。

1. script 模块概述 - 运行脚本 💻

通过 script 模块，你可以将一个本地的脚本文件传输到目标主机并执行。脚本可以是任何可执行的文件（例如 .sh 文件、Python 脚本等）。此模块是自动化部署和执行自定义脚本的好方法。

常见参数：

• src：要上传并执行的本地脚本路径（必需）。

• dest：远程主机上脚本的存储位置（可选，默认是临时文件夹）。

• executable ：指定用于执行脚本的解释器或执行程序（如 /bin/bash 或 /usr/bin/python）。

• creates：在执行脚本之前检查目标文件是否存在，如果存在则跳过脚本执行（可选）。

• chmod：为远程文件设置权限（可选）。

---

2. 基本用法 - 在远程主机上执行本地脚本 🖥️

假设你有一个本地脚本 install.sh，该脚本用于在目标主机上执行某些任务（如安装软件包等）。你可以使用 script 模块将该脚本传输到远程主机并执行。

- name: Run install.sh script on remote host
  hosts: all
  tasks:
    - name: Execute the install script
      script: /path/to/install.sh

• script: /path/to/install.sh：指定本地脚本文件路径，Ansible 会将脚本上传到远程主机并执行。

---

3. 指定远程存储路径 - 使用 dest 参数 📂

如果你希望将脚本存储到远程主机的特定路径，可以通过 dest 参数来指定存储位置。

- name: Run script and store it in specific location
  hosts: all
  tasks:
    - name: Execute the install script from a specific path
      script:
        src: /path/to/install.sh
        dest: /tmp/install.sh

• dest: /tmp/install.sh ：将脚本上传到远程主机的 /tmp 目录并执行。

---

4. 使用 executable 指定执行器 🏃‍♀️

如果你希望脚本使用特定的解释器或执行程序（如 Bash、Python），可以通过 executable 参数指定。默认情况下，script 模块使用默认的 Shell 来执行脚本。

- name: Run a Python script
  hosts: all
  tasks:
    - name: Execute the Python script
      script:
        src: /path/to/script.py
        executable: /usr/bin/python3

• executable: /usr/bin/python3：指定使用 Python 3 解释器来执行 Python 脚本。

---

5. 使用 creates 参数避免重复执行 🔄

有时你希望避免多次运行相同的脚本，特别是在脚本完成某项任务后（如安装软件、配置文件等）。creates 参数允许你指定一个文件，如果该文件存在，则跳过脚本的执行。

- name: Run script only if file does not exist
  hosts: all
  tasks:
    - name: Execute the script only if /tmp/installed_marker does not exist
      script:
        src: /path/to/install.sh
        creates: /tmp/installed_marker

• creates: /tmp/installed_marker ：如果文件 /tmp/installed_marker 已经存在，脚本将不会执行。

---

6. 设置脚本权限 - 使用 chmod 参数 🔒

有时你需要确保脚本在远程主机上具有适当的执行权限，特别是在文件系统中权限设置不正确时。你可以使用 chmod 参数为脚本设置权限。

- name: Run a script with appropriate permissions
  hosts: all
  tasks:
    - name: Set execute permissions for script
      script:
        src: /path/to/install.sh
        chmod: 'u+x'

• chmod: 'u+x'：为文件设置可执行权限，确保脚本在远程主机上能够正确执行。

---

7. 综合示例 - 使用 script 模块执行多个任务 🎯

- name: Execute custom scripts on remote hosts
  hosts: all
  tasks:
    - name: Run the installation script
      script: /path/to/install.sh
      dest: /tmp/install.sh

    - name: Run the cleanup script
      script: /path/to/cleanup.sh
      dest: /tmp/cleanup.sh
      creates: /tmp/cleanup_done

    - name: Execute Python script with specific interpreter
      script:
        src: /path/to/script.py
        executable: /usr/bin/python3

• 多个脚本：可以根据任务的不同需求，在同一 Playbook 中运行多个脚本。

• creates 参数：避免重复执行清理脚本。

---

8. 总结 - script 模块的应用场景 💡

script 模块是 Ansible 中一个非常强大的工具，能够在远程主机上执行本地脚本。无论是进行系统配置、安装软件、进行日志分析，还是执行复杂的操作任务，script 模块都能帮助你轻松实现自动化。

应用场景：

• 在远程主机上执行定制化脚本。

• 将本地脚本上传并执行，解决脚本无法在远程主机上直接访问的问题。

• 自动化安装、升级、配置等任务。

• 在执行某些命令之前，通过 creates 参数防止重复执行。

通过熟练掌握 script 模块，你可以将许多手动操作自动化，提升工作效率，减少人为错误！

---

与shell模块的区别

特点	script 模块	shell 模块
执行方式	上传并执行本地脚本	直接在远程主机的 shell 中执行命令或脚本
输入内容	传输本地脚本文件（.sh、.py 等）	直接在 shell 模块中编写命令
执行环境	根据脚本文件的扩展名或 executable 参数指定	使用默认 shell（通常是 /bin/sh）或指定的 shell
文件传输	会将本地脚本文件传输到远程主机	不涉及文件传输，仅执行命令
使用场景	当你需要上传并执行本地脚本时（例如安装包、配置脚本等）	当你希望直接在远程主机上执行简单命令或脚本时
文件存在检查	creates：如果目标文件已存在则跳过执行	creates：如果目标文件已存在则跳过执行

unarchive模块

远程压缩包的管理。

Ansible 的 unarchive 模块用于在远程主机上解压缩和管理压缩包。它可以解压 .tar、.zip、.gz、.bz2 等格式的压缩包。通过 unarchive 模块，你可以方便地将压缩包从本地上传到远程主机并进行解压，或者直接从远程主机下载并解压文件。

1. unarchive 模块概述 - 管理压缩包 🗂️

unarchive 模块非常适用于自动化部署过程中需要解压软件包、安装程序或其他压缩文件的场景。它支持不同格式的压缩文件（如 .tar、.gz、.zip 等），并可以直接操作远程文件系统中的压缩包。

常用参数：

• src：压缩包的源路径。可以是本地路径（需要通过 Ansible 上传），也可以是远程 URL。

• dest：指定解压文件的目标目录（必需）。

• remote_src ：是否从远程源解压文件。如果 src 指定的是远程文件（例如，已经存在的远程路径），则需要设置此参数为 yes。

• creates：指定目标文件路径。如果该文件已存在，任务将跳过解压操作。

• owner 、group：指定解压后的文件的所有者和所属组。

• mode：设置解压后文件的权限。

• copy ：指定是否将压缩包从本地复制到远程主机。如果设置为 no，src 必须是一个远程路径。

---

2. 基本用法 - 解压本地压缩包 📂

下面是一个简单的示例，展示了如何将本地压缩包传输到远程主机并解压。

- name: Unarchive a local file to remote host
  hosts: all
  tasks:
    - name: Extract tar.gz archive to /opt directory
      unarchive:
        src: /path/to/archive.tar.gz
        dest: /opt/
        remote_src: no

• src: /path/to/archive.tar.gz：指定本地的压缩包路径。

• dest: /opt/：指定解压后的目标目录。

• remote_src: no ：表示 src 是本地文件路径，需要将文件上传到远程主机。

---

3. 从远程 URL 下载并解压 📥

如果你的压缩包位于远程 URL（例如，从网站或文件服务器上下载），你可以使用 unarchive 模块直接下载并解压文件。

- name: Download and extract tar.gz archive from URL
  hosts: all
  tasks:
    - name: Download and extract archive from URL
      unarchive:
        src: https://example.com/archive.tar.gz
        dest: /opt/
        remote_src: no

• src: https://example.com/archive.tar.gz：直接从指定的 URL 下载压缩包。

• dest: /opt/：指定解压后的目标目录。

---

4. 解压远程主机上的压缩包 🌍

如果压缩包已经存在于远程主机上，你可以直接解压，而无需将文件上传。此时，设置 remote_src: yes。

- name: Unarchive a remote file on the target host
  hosts: all
  tasks:
    - name: Extract remote tar.gz archive
      unarchive:
        src: /tmp/archive.tar.gz
        dest: /opt/
        remote_src: yes

• src: /tmp/archive.tar.gz：远程主机上的压缩包路径。

• dest: /opt/：目标目录。

---

5. 设置文件权限和所有者 🛠️

你可以通过 owner、group 和 mode 参数来设置解压后的文件权限和所有者。

- name: Extract and set file ownership and permissions
  hosts: all
  tasks:
    - name: Extract tar.gz archive and set permissions
      unarchive:
        src: /path/to/archive.tar.gz
        dest: /opt/
        remote_src: no
        owner: root
        group: root
        mode: '0755'

• owner: root：指定文件的所有者。

• group: root：指定文件的所属组。

• mode: '0755'：指定文件权限。

---

6. 使用 creates 参数避免重复解压 🔄

为了避免每次运行 Playbook 时都解压相同的压缩包，可以使用 creates 参数，指定一个解压后应该存在的文件。如果该文件已存在，解压操作将被跳过。

- name: Unarchive the file only if not already extracted
  hosts: all
  tasks:
    - name: Extract tar.gz archive only if /opt/some_file exists
      unarchive:
        src: /path/to/archive.tar.gz
        dest: /opt/
        remote_src: no
        creates: /opt/some_file

• creates: /opt/some_file ：如果 /opt/some_file 文件已存在，解压操作将被跳过。

---

7. 完整示例 - 解压操作应用场景 🎯

假设你有一个包含多个压缩包的目录，Ansible Playbook 可以帮助你将这些文件解压到不同的目录。

- name: Unarchive multiple files on remote hosts
  hosts: all
  tasks:
    - name: Extract first archive
      unarchive:
        src: /path/to/archive1.tar.gz
        dest: /opt/archive1/
        remote_src: no
        creates: /opt/archive1/some_file

    - name: Extract second archive
      unarchive:
        src: /path/to/archive2.tar.gz
        dest: /opt/archive2/
        remote_src: no
        creates: /opt/archive2/some_file

• 这个示例演示了如何解压多个文件并避免重复解压。

---

8. 总结

• unarchive 模块 是 Ansible 中非常实用的模块，用于处理压缩文件，支持上传、解压、文件权限管理等功能。

• 应用场景：当你需要自动化部署时，使用该模块可以方便地解压远程服务器上的文件，或者将本地文件上传并解压。

• 参数：

  • src：压缩包路径（本地路径或 URL）。

  • dest：解压目标目录。

  • remote_src：指定源是否是远程文件。

  • creates：防止重复解压。

  • owner、group、mode：控制解压后文件的权限和所有者。

通过灵活使用 unarchive 模块，你可以更高效地管理和解压远程主机上的压缩文件，自动化运维变得更加轻松！

role-角色扮演

playbooks的目录结构

非常好，这部分我们进入了 Ansible 的高阶用法 ------ Role（角色） 与 Playbooks 的目录结构，它们是构建大型、可复用自动化项目的关键。

你可以把它理解为一个"分工明确的剧组"：

• Playbook 就像剧本，

• Role 是演员的脚本，

• 每个角色（role）都干好自己的一摊事，Playbook 把它们组合成一场完整的大戏。

---

✅ 一、什么是 Role？

**Role 是 Ansible 的一种自动化组织方式，**它将任务、变量、文件、模板等内容封装在一个统一结构下，实现 可复用、可维护、易于协作 的自动化部署模块。

你可以用一句话记住它：

"Role = 一组标准化的任务 + 它需要的文件、变量、模板等资源"。

---

🗂️ 二、Playbook 项目推荐目录结构（标准）

site.yml                 # 主 playbook
inventory/
│   └── hosts            # 主机清单
group_vars/
│   ├── all.yml          # 所有主机组变量
│   └── webservers.yml   # 针对 webservers 组的变量
roles/
├── common/              # 一个 role：common
│   ├── tasks/           # 任务（必须）
│   │   └── main.yml
│   ├── files/           # 静态文件（可选）
│   ├── templates/       # Jinja2 模板文件（可选）
│   ├── vars/            # 变量（可选）
│   ├── defaults/        # 默认变量（可选，优先级最低）
│   ├── handlers/        # 触发的动作（可选）
│   └── meta/            # 依赖关系定义（可选）
├── webserver/
│   ├── tasks/
│   │   └── main.yml
│   └── templates/
│       └── index.html.j2

---

🧠 三、Role 的执行方式（怎么在 Playbook 中调用）

# site.yml
- name: Apply roles
  hosts: webservers
  roles:
    - common
    - webserver

这样，Ansible 就会自动去 roles/common/tasks/main.yml 和 roles/webserver/tasks/main.yml 执行任务。

---

📌 四、快速创建 Role 的命令

Ansible 提供了命令帮助你快速生成 role 的标准目录结构：

ansible-galaxy init myrole

执行后会生成：

myrole/
├── defaults
├── files
├── handlers
├── meta
├── tasks
├── templates
├── tests
└── vars

你只需要往这些目录里"填剧本"就行了。

---

📘 五、tasks/main.yml 示例

# roles/webserver/tasks/main.yml
- name: 安装 httpd
  yum:
    name: httpd
    state: present

- name: 启动 httpd 服务
  service:
    name: httpd
    state: started

---

🌟 总结回顾

结构	作用
tasks/	编排任务的主角，必须有！
files/	要传输的静态文件
templates/	动态模板文件，支持变量替换
vars/	明确设置的变量，优先级高
defaults/	默认变量（优先级低）
handlers/	被 notify 唤起的动作，如重启服务等
meta/	设置依赖、说明

---

你可以这样理解 Role：

"Playbook 是剧本，Role 是各司其职的专业演员，只有协作好才能成就一出好戏。"

需要我帮你写一个完整 Role 的示例吗？还是你想我帮你生成目录结构和内容文件？

剧本实战

非常棒！我们现在进入一个实战模块，用 Ansible Playbook 部署 Nginx 服务，从任务编写、模板配置到最终测试，全流程教学，适合入门 + 进阶整合学习。

---

✅ 一、Nginx Playbook 实战之 tasks：部署任务编写

Playbook 路径：roles/nginx/tasks/main.yml

# 安装 epel-release，Nginx 依赖
- name: 安装 EPEL 仓库
  yum:
    name: epel-release
    state: present

# 安装 nginx
- name: 安装 Nginx
  yum:
    name: nginx
    state: present

# 启动并设置开机启动
- name: 启动 Nginx
  service:
    name: nginx
    state: started
    enabled: yes

---

🧠 二、Nginx Playbook 实战之 templates：动态配置文件

模板文件路径： roles/nginx/templates/nginx.conf.j2

# nginx.conf.j2 - 模板文件
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    sendfile on;
    keepalive_timeout 65;

    server {
        listen 80;
        server_name {{ nginx_server_name }};
        root {{ nginx_web_root }};
        index index.html;
    }
}

在任务中使用模板：

# roles/nginx/tasks/main.yml 追加
- name: 配置 Nginx 主配置文件
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: 重启 Nginx

添加 handler： roles/nginx/handlers/main.yml

- name: 重启 Nginx
  service:
    name: nginx
    state: restarted

---

🌐 三、Nginx Playbook 实战之 site.yml：整合部署剧本

主 Playbook：site.yml

- name: 部署 Nginx 服务
  hosts: webservers
  become: true
  vars:
    nginx_server_name: www.example.com
    nginx_web_root: /usr/share/nginx/html
  roles:
    - nginx

---

🧪 四、Nginx Playbook 实战之测试：验证部署效果

1. 执行 Playbook：

   ansible-playbook -i inventory/hosts site.yml

2. 验证是否安装成功：

   curl http://<webserver_ip>

3. 查看服务状态：

   ansible -i inventory/hosts webservers -m shell -a "systemctl status nginx"

---

✨ 总结与亮点

模块	内容亮点
tasks	自动安装、配置、启用 nginx 服务
template	灵活动态生成配置文件，支持变量
site	集中式 orchestration（编排）
测试	保证部署后的可达性和服务正确性

---

部署的乐趣是：写剧本如写诗，一键即上线！

如果你愿意，我可以再帮你加上 SSL、反向代理等高级用法 😎

你想继续升级实战内容吗？