【Ansible】第六期：Ansible 进阶实战：批量管理 K8s 集群 / 云主机，适配企业级场景
·
目录
模块 2：kubectl—— 执行原生 kubectl 命令
2.3 完整 Playbook 实战（k8s_manage.yml）
三、实战 2：用 Ansible 管理阿里云 ECS 实例（批量创建 + 配置）
模块 1：aliyun_ecs_instance—— 创建 / 管理 ECS 实例
模块 2：aliyun_security_group—— 创建 / 配置安全组
模块 3：aliyun_ecs_disk—— 创建并挂载云盘
3.3 完整 Playbook 实战（aliyun_ecs_manage.yml）
四、实战 3：Ansible + Cron 实现定时自动化（日志清理）
一、前言：从 “基础操作” 到 “业务落地” 的跨越
在掌握 Ansible 基础语法（Playbook、模块、Inventory）后，企业级场景的核心需求是将自动化能力与实际业务绑定—— 例如批量运维 K8s 容器集群、高效管理云厂商资源（如阿里云 ECS）、实现定时重复性任务的自动化执行。
本文聚焦 “云资源 / 容器集群” 两大核心场景，通过 “场景定义→环境准备→核心模块解析→完整 Playbook 实战→问题排查” 的闭环流程，带您落地可直接复用的企业级自动化方案，解决 “手动操作效率低、多节点一致性差、重复任务耗人力” 的痛点。
二、实战 1：用 Ansible 批量管理 K8s 集群
2.1 场景定义与前置条件
核心场景
对多台 K8s 节点（Master + Node）执行标准化操作，覆盖 “节点初始化→资源部署→状态校验” 全流程，具体包括：
- 为所有 K8s Node 节点安装并启动 kubelet 服务；
- 在 K8s Master 节点部署 Nginx 应用的 Deployment（3 副本）；
- 批量查看所有 Node 节点的 Pod 运行状态，并校验副本数是否达标。
前置环境准备
| 组件 | 要求说明 |
|---|---|
| Ansible 控制节点 | 已安装 Ansible 2.10+，且能通过 SSH 免密登录所有 K8s 节点（配置 Inventory） |
| K8s 集群 | 已初始化 K8s 集群（如通过 kubeadm 部署），Master 节点可正常执行 kubectl 命令 |
| 依赖模块 | 确保 Ansible 已加载 k8s 和 kubectl 模块（Ansible 2.8+ 自带，无需额外安装） |
| Inventory 配置 | 已将 K8s 节点按角色分组（如 [k8s-master]、[k8s-nodes]） |
Inventory 示例（inventory.ini）：
[k8s-master]
192.168.1.100 ansible_user=root ansible_port=22
[k8s-nodes]
192.168.1.101 ansible_user=root ansible_port=22
192.168.1.102 ansible_user=root ansible_port=22
# 所有 K8s 节点的通用变量
[k8s:children]
k8s-master
k8s-nodes
[k8s:vars]
kubelet_service_name=kubelet
2.2 核心模块深度解析
本次实战依赖 Ansible 专为 K8s 设计的两大核心模块，需理解其适用场景与参数逻辑：
模块 1：k8s—— 原生操作 K8s 资源
k8s 模块是 Ansible 与 K8s API 直接交互的核心，支持创建 / 删除 / 更新 K8s 资源（Deployment、Service、ConfigMap 等），无需在控制节点安装 kubectl，更适合标准化 Playbook。
核心参数说明：
| 参数名 | 作用说明 | 示例值 |
|---|---|---|
state |
资源状态：present（创建 / 更新）、absent（删除） |
present |
api_version |
K8s 资源的 API 版本（需与资源类型匹配，如 Deployment 用 apps/v1） |
apps/v1 |
kind |
K8s 资源类型（如 Deployment、Pod、Service） | Deployment |
name |
资源名称 | nginx-deploy |
namespace |
资源所属命名空间（默认 default） |
default |
spec |
资源的详细配置（与 K8s YAML 中的 spec 字段完全一致） |
见下方 Playbook 示例 |
definition |
直接引用外部 K8s YAML 文件（替代 api_version/kind/spec 等参数） |
{{ lookup('file', 'deployment.yml') }} |
模块 2：kubectl—— 执行原生 kubectl 命令
kubectl 模块本质是在目标节点（通常是 K8s Master）执行 kubectl 命令，适合需要自定义命令输出、或执行 k8s 模块未覆盖的操作（如 kubectl logs、kubectl exec）。
核心参数说明：
| 参数名 | 作用说明 | 示例值 |
|---|---|---|
command |
要执行的 kubectl 完整命令（无需加 kubectl 前缀） |
get pods -n default -o wide |
namespace |
指定命名空间（等价于命令中的 -n 参数，可省略） |
default |
output |
命令输出格式（如 json、yaml、wide），便于后续结果校验 |
json |
2.3 完整 Playbook 实战（k8s_manage.yml）
Playbook 按 “节点初始化→资源部署→状态校验” 分阶段设计，包含任务失败重试、结果断言等企业级特性：
---
- name: 阶段 1：K8s Node 节点初始化（安装并启动 kubelet）
hosts: k8s-nodes # 仅对 Node 节点执行
gather_facts: true # 收集节点系统信息（如操作系统版本）
become: true # 提权执行（安装服务需 root 权限）
retries: 3 # 任务失败时重试 3 次
delay: 5 # 重试间隔 5 秒
tasks:
- name: 1.1 安装 kubelet 服务（以 CentOS 为例，用 yum 安装）
yum:
name: kubelet
state: present # 确保服务已安装
update_cache: true # 刷新 yum 缓存
- name: 1.2 启动 kubelet 服务，并设置开机自启
service:
name: "{{ kubelet_service_name }}" # 引用 Inventory 中的变量
state: started
enabled: true # 开机自启
- name: 1.3 校验 kubelet 服务状态
command: systemctl is-active {{ kubelet_service_name }}
register: kubelet_status # 将命令输出存入变量
- name: 1.4 断言 kubelet 服务已正常运行（失败则终止 Playbook）
assert:
that:
- "'active' in kubelet_status.stdout" # 校验输出中包含 "active"
fail_msg: "ERROR: kubelet 服务未正常启动！"
success_msg: "SUCCESS: kubelet 服务已正常运行"
- name: 阶段 2：在 K8s Master 部署 Nginx Deployment
hosts: k8s-master # 仅对 Master 节点执行
gather_facts: false
become: true
tasks:
- name: 2.1 用 k8s 模块创建 Nginx Deployment（3 副本）
k8s:
state: present
api_version: apps/v1
kind: Deployment
name: nginx-deploy
namespace: default
spec:
replicas: 3 # 期望副本数
selector:
matchLabels:
app: nginx # 匹配 Pod 的标签
template:
metadata:
labels:
app: nginx # 给 Pod 打标签
spec:
containers:
- name: nginx
image: nginx:alpine # 轻量级 Nginx 镜像
ports:
- containerPort: 80 # 容器暴露 80 端口
resources: # 资源限制（企业级场景必配，避免资源抢占）
requests:
cpu: "100m" # 最小 CPU 需求（100 毫核）
memory: "128Mi" # 最小内存需求
limits:
cpu: "500m"
memory: "256Mi"
- name: 2.2 等待 Deployment 副本就绪（最多等待 60 秒）
kubectl:
command: rollout status deployment/nginx-deploy -n default
register: rollout_status
until: "'successfully rolled out' in rollout_status.stdout" # 等待成功信息
retries: 12 # 重试 12 次（12*5=60 秒）
delay: 5
- name: 阶段 3：批量查看 Pod 状态并校验副本数
hosts: k8s-master
gather_facts: false
tasks:
- name: 3.1 查看 default 命名空间下的所有 Pod（输出 JSON 格式）
kubectl:
command: get pods -n default -o json
register: pod_list # 将 Pod 列表存入变量（JSON 格式）
- name: 3.2 提取 Nginx Pod 的数量（通过 JSON 过滤）
set_fact:
nginx_pod_count: "{{ pod_list.stdout | from_json | json_query('items[?metadata.labels.app==`nginx`] | length') }}"
# 解释：1. 将 JSON 字符串转为字典 → 2. 用 json_query 过滤标签为 app=nginx 的 Pod → 3. 统计数量
- name: 3.3 断言 Nginx Pod 副本数为 3（与期望一致）
assert:
that:
- nginx_pod_count | int == 3
fail_msg: "ERROR: Nginx Pod 副本数为 {{ nginx_pod_count }}，期望 3！"
success_msg: "SUCCESS: Nginx Pod 副本数达标（{{ nginx_pod_count }}/3）"
- name: 3.4 （可选）将 Pod 状态信息同步到所有 Node 节点（便于节点本地查看）
copy:
content: "{{ pod_list.stdout | from_json | to_nice_json }}" # 格式化 JSON 输出
dest: /root/k8s_pod_status.json
mode: '0644' # 文件权限
delegate_to: "{{ item }}" # 遍历所有 Node 节点
loop: "{{ groups['k8s-nodes'] }}" # 引用 Inventory 中的 Node 分组
2.4 执行与结果验证
1. 执行 Playbook
在 Ansible 控制节点运行以下命令，指定 Inventory 和 Playbook 文件：
ansible-playbook -i inventory.ini k8s_manage.yml
2. 关键结果验证点
- 阶段 1 验证：登录任意 K8s Node 节点，执行
systemctl status kubelet，确认服务处于active (running)状态。 - 阶段 2 验证：在 K8s Master 节点执行
kubectl get deploy nginx-deploy -n default，查看READY列是否为3/3。 - 阶段 3 验证：
- 在 Master 节点查看断言结果，确认输出
SUCCESS: Nginx Pod 副本数达标； - 在 Node 节点查看
/root/k8s_pod_status.json，确认包含 Nginx Pod 的详细状态（如 IP、所在节点）。
- 在 Master 节点查看断言结果，确认输出
3. 常见问题排查
| 问题现象 | 排查方向 |
|---|---|
| kubelet 安装失败 | 检查 Node 节点是否已配置 K8s 官方 YUM 源（需提前配置，否则 yum 找不到包） |
Deployment 副本一直未就绪（0/3） |
1. 检查 Master 与 Node 网络是否通（如 6443 端口）；2. 查看 Pod 日志：kubectl logs <pod-name> |
| 断言失败（副本数不达标） | 1. 检查 K8s 节点资源是否充足（如内存不足导致 Pod 无法启动）；2. 查看 Deployment 事件：kubectl describe deploy nginx-deploy |
三、实战 2：用 Ansible 管理阿里云 ECS 实例（批量创建 + 配置）
3.1 场景定义与前置条件
核心场景
企业级云资源管理的典型需求：批量创建 2 台阿里云 ECS 实例（用于部署 Web 服务），并完成 “云盘挂载→安全组配置→系统初始化” 的自动化流程，避免手动在阿里云控制台重复操作。
前置环境准备
| 组件 | 要求说明 |
|---|---|
| Ansible 控制节点 | 已安装 Python 3.6+，且能访问阿里云 API（需开放网络出口，允许访问 ecs.aliyuncs.com） |
| 阿里云账号权限 | 账号需具备 ECS 实例创建、安全组管理、云盘管理 权限（建议创建 RAM 子账号，避免使用主账号） |
| 依赖模块与 SDK | 安装阿里云 Ansible 模块和 Python SDK：pip install aliyun-python-sdk-ecs ansible-modules-aliyun |
| 阿里云密钥配置 | 已获取 RAM 子账号的 AccessKey ID 和 AccessKey Secret（用于调用 API） |
3.2 核心模块与参数解析
本次实战依赖阿里云专属 Ansible 模块，核心模块如下：
模块 1：aliyun_ecs_instance—— 创建 / 管理 ECS 实例
核心参数说明（仅列关键参数，完整参数见阿里云官方文档）：
| 参数名 | 作用说明 | 示例值 |
|---|---|---|
access_key |
RAM 子账号的 AccessKey ID（建议用 Vault 加密，避免明文） | LTAIxxxxxx |
secret_key |
RAM 子账号的 AccessKey Secret | xxxxxx |
region |
阿里云地域（如上海 cn-shanghai、北京 cn-beijing） |
cn-shanghai |
instance_name |
ECS 实例名称（支持变量，实现批量命名） | web-server-{{ item }} |
instance_type |
ECS 实例规格（如 ecs.g6.large：2C4G） |
ecs.g6.large |
image_id |
系统镜像 ID（如 CentOS 7.9 64 位：centos_7_9_x64_20G_alibase_20240520.vhd） |
需根据地域选择对应镜像 ID |
internet_charge_type |
网络计费方式（PayByTraffic 按流量计费，PayByBandwidth 按带宽计费） |
PayByTraffic |
internet_max_bandwidth_out |
公网出带宽上限（单位：Mbps） | 10 |
security_group_ids |
绑定的安全组 ID（需提前创建或通过模块创建） | ["sg-xxxxxx"] |
count |
批量创建实例数量（或通过 loop 遍历创建） |
2 |
state |
实例状态（present 创建，absent 删除） |
present |
模块 2：aliyun_security_group—— 创建 / 配置安全组
用于创建安全组并开放必要端口（如 22 端口用于 SSH 登录、80 端口用于 Web 服务）：
| 参数名 | 作用说明 | 示例值 |
|---|---|---|
name |
安全组名称 | web-server-sg |
description |
安全组描述 | 允许 SSH 和 HTTP 访问的安全组 |
rules |
安全组入方向规则（列表形式，支持多规则） | 见下方 Playbook 示例 |
rule_direction |
规则方向（ingress 入方向，egress 出方向） |
ingress |
模块 3：aliyun_ecs_disk—— 创建并挂载云盘
为 ECS 实例添加数据盘（如 100GB），并挂载到 /data 目录：
| 参数名 | 作用说明 | 示例值 |
|---|---|---|
disk_size |
云盘大小（单位：GB，最小 20GB，步长 10GB） | 100 |
disk_category |
云盘类型（cloud_efficiency 高效云盘、cloud_ssd SSD 云盘） |
cloud_efficiency |
instance_id |
关联的 ECS 实例 ID（需先创建实例，再通过变量引用） | {{ ecs_instance.instance_id }} |
device |
云盘挂载设备名（Linux 系统建议用 /dev/vdb、/dev/vdc 等） |
/dev/vdb |
state |
云盘状态（present 创建并挂载，absent 卸载并删除） |
present |
3.3 完整 Playbook 实战（aliyun_ecs_manage.yml）
Playbook 按 “安全组创建→ECS 实例批量创建→云盘挂载→系统初始化” 流程设计，包含敏感信息引用、实例信息注册等企业级细节：
---
- name: 阶段 1：创建阿里云安全组（开放 SSH + HTTP 端口）
hosts: localhost # 云资源操作无需远程节点，在控制节点本地执行
gather_facts: false
vars:
# 阿里云基础配置（建议用 Ansible Vault 加密，此处为示例）
aliyun_access_key: "LTAIxxxxxx"
aliyun_secret_key: "xxxxxx"
aliyun_region: "cn-shanghai"
security_group_name: "web-server-sg-2024"
security_group_desc: "允许 SSH(22) 和 HTTP(80) 访问，拒绝其他端口"
tasks:
- name: 1.1 创建安全组
aliyun_security_group:
access_key: "{{ aliyun_access_key }}"
secret_key: "{{ aliyun_secret_key }}"
region: "{{ aliyun_region }}"
name: "{{ security_group_name }}"
description: "{{ security_group_desc }}"
state: present
register: security_group_result # 注册安全组信息（含安全组 ID）
- name: 1.2 配置安全组入方向规则（允许 SSH 访问）
aliyun_security_group_rule:
access_key: "{{ aliyun_access_key }}"
secret_key: "{{ aliyun_secret_key }}"
region: "{{ aliyun_region }}"
security_group_id: "{{ security_group_result.group_id }}"
rule_direction: ingress
ip_protocol: tcp
port_range: "22/22" # 仅开放 22 端口
cidr_ip: "0.0.0.0/0" # 允许所有 IP 访问（生产环境建议限制公司公网 IP）
priority: 100 # 规则优先级（1-100，数值越小优先级越高）
state: present
- name: 1.3 配置安全组入方向规则（允许 HTTP 访问）
aliyun_security_group_rule:
access_key: "{{ aliyun_access_key }}"
secret_key: "{{ aliyun_secret_key }}"
region: "{{ aliyun_region }}"
security_group_id: "{{ security_group_result.group_id }}"
rule_direction: ingress
ip_protocol: tcp
port_range: "80/80" # 开放 80 端口（Web 服务）
cidr_ip: "0.0.0.0/0"
priority: 110
state: present
- name: 阶段 2：批量创建 2 台 ECS 实例
hosts: localhost
gather_facts: false
vars:
aliyun_access_key: "LTAIxxxxxx"
aliyun_secret_key: "xxxxxx"
aliyun_region: "cn-shanghai"
instance_spec: "ecs.g6.large" # 2C4G 实例规格
image_id: "centos_7_9_x64_20G_alibase_20240520.vhd" # CentOS 7.9 镜像（上海地域）
instance_count: 2 # 批量创建数量
security_group_id: "{{ hostvars['localhost']['security_group_result']['group_id'] }}" # 引用上一阶段的安全组 ID
tasks:
- name: 2.1 批量创建 ECS 实例
aliyun_ecs_instance:
access_key: "{{ aliyun_access_key }}"
secret_key: "{{ aliyun_secret_key }}"
region: "{{ aliyun_region }}"
instance_name: "web-server-{{ item + 1 }}" # 实例命名：web-server-1、web-server-2
instance_type: "{{ instance_spec }}"
image_id: "{{ image_id }}"
security_group_ids: ["{{ security_group_id }}"]
internet_charge_type: "PayByTraffic" # 按流量计费
internet_max_bandwidth_out: 10 # 公网出带宽 10Mbps
system_disk_category: "cloud_efficiency" # 系统盘：高效云盘
system_disk_size: 50 # 系统盘大小 50GB
count: "{{ instance_count }}"
state: present
register: ecs_instances # 注册实例列表（含实例 ID、公网 IP 等）
loop: "{{ range(instance_count) | list }}" # 循环创建实例
- name: 2.2 输出 ECS 实例信息（便于后续操作）
debug:
msg:
- "实例名称：{{ item.instance_name }}"
- "实例 ID：{{ item.instance_id }}"
- "公网 IP：{{ item.public_ip_address[0] }}"
- "内网 IP：{{ item.private_ip_address[0] }}"
loop: "{{ ecs_instances.results }}" # 遍历实例列表
- name: 阶段 3：为每台 ECS 实例挂载 100GB 数据盘
hosts: localhost
gather_facts: false
vars:
aliyun_access_key: "LTAIxxxxxx"
aliyun_secret_key: "xxxxxx"
aliyun_region: "cn-shanghai"
data_disk_size: 100 # 数据盘大小 100GB
ecs_instances_list: "{{ hostvars['localhost']['ecs_instances']['results'] }}" # 引用实例列表
tasks:
- name: 3.1 创建并挂载数据盘
aliyun_ecs_disk:
access_key: "{{ aliyun_access_key }}"
secret_key: "{{ aliyun_secret_key }}"
region: "{{ aliyun_region }}"
disk_name: "data-disk-{{ item.instance_id }}" # 云盘命名：关联实例 ID
disk_size: "{{ data_disk_size }}"
disk_category: "cloud_efficiency"
instance_id: "{{ item.instance_id }}"
device: "/dev/vdb" # 挂载设备名
state: present
loop: "{{ ecs_instances_list }}" # 为每个实例挂载数据盘
- name: 阶段 4：ECS 实例系统初始化（格式化数据盘 + 安装基础工具）
hosts: "{{ ecs_instances_list | map(attribute='public_ip_address.0') | list }}" # 动态指定 ECS 公网 IP 为目标主机
gather_facts: true
become: true
vars:
ecs_instances_list: "{{ hostvars['localhost']['ecs_instances']['results'] }}"
data_disk_device: "/dev/vdb" # 数据盘设备名（与阶段 3 一致）
data_mount_point: "/data" # 数据盘挂载点
tasks:
- name: 4.1 安装磁盘分区工具（parted）
yum:
name: parted
state: present
update_cache: true
- name: 4.2 格式化数据盘（ext4 文件系统）
command: "{{ item }}"
args:
creates: "{{ data_mount_point }}" # 若挂载点已存在，跳过此任务
with_items:
- "parted -s {{ data_disk_device }} mklabel gpt" # 创建 GPT 分区表
- "parted -s {{ data_disk_device }} mkpart primary ext4 0% 100%" # 创建全量主分区
- "mkfs.ext4 {{ data_disk_device }}1" # 格式化分区为 ext4
- name: 4.3 创建数据盘挂载点
file:
path: "{{ data_mount_point }}"
state: directory
mode: '0755'
- name: 4.4 配置 /etc/fstab，实现数据盘开机自动挂载
mount:
path: "{{ data_mount_point }}"
src: "{{ data_disk_device }}1"
fstype: ext4
state: mounted # 立即挂载并写入 fstab
- name: 4.5 安装基础工具（wget、vim、net-tools）
yum:
name:
- wget
- vim
- net-tools
state: present
3.4 执行与结果验证
1. 执行 Playbook
在 Ansible 控制节点运行命令，因涉及敏感信息（AccessKey），建议用 Vault 加密后执行（下文附 Vault 加密步骤）：
# 1. （可选）用 Vault 加密 Playbook 中的敏感变量（创建加密文件）
ansible-vault create aliyun_secrets.yml
# 输入密码后，在文件中写入：
# aliyun_access_key: "LTAIxxxxxx"
# aliyun_secret_key: "xxxxxx"
# 2. 引用加密文件执行 Playbook
ansible-playbook -i inventory.ini aliyun_ecs_manage.yml --extra-vars "@aliyun_secrets.yml" --ask-vault-pass
2. 关键结果验证点
- 安全组验证：登录阿里云控制台 → 云服务器 ECS → 网络与安全 → 安全组，确认
web-server-sg-2024已创建，且入方向规则包含 22 和 80 端口。 - ECS 实例验证：在控制台 “实例列表” 中，确认 2 台实例（
web-server-1、web-server-2）状态为 “运行中”，且绑定目标安全组。 - 数据盘验证：SSH 登录任意 ECS 实例，执行
df -h，确认/data分区已挂载（大小约 100GB），且cat /etc/fstab包含自动挂载配置。 - 工具验证：在 ECS 实例中执行
wget --version或vim --version，确认基础工具已安装。
3. 常见问题排查
| 问题现象 | 排查方向 | |
|---|---|---|
| 创建 ECS 实例失败，提示 “权限不足” | 1. 检查 RAM 子账号是否已授予 AliyunECSFullAccess 权限；2. 确认 AccessKey 未过期 |
|
| 数据盘格式化失败，提示 “设备忙” | 1. 检查数据盘是否已被挂载（`mount | grep /dev/vdb）；2. 确认设备名是否正确（不同实例可能为 /dev/vdc`） |
| 无法 SSH 登录 ECS 实例 | 1. 检查安全组是否开放 22 端口；2. 确认实例公网 IP 正确；3. 检查控制节点网络是否能访问阿里云 22 端口 |
四、实战 3：Ansible + Cron 实现定时自动化（日志清理）
4.1 场景定义
企业级运维中，被控节点（如 K8s Node、ECS 实例）的日志文件会持续占用磁盘空间，需每天凌晨 3 点自动清理 7 天前的旧日志（路径 /var/log/old/），避免手动执行重复任务。
4.2 实现原理
通过 “Ansible 命令行任务 + Linux Cron 定时任务” 结合，无需编写复杂 Playbook，适合简单重复性操作：
- Ansible 任务：用
shell模块批量执行日志清理命令； - Cron 定时任务：在 Ansible 控制节点配置 Cron，指定每天凌晨 3 点触发 Ansible 任务。
4.3 完整操作步骤
步骤 1：测试 Ansible 日志清理命令
先在控制节点手动执行命令，验证清理逻辑是否正常（避免直接配置定时任务导致误删）：
# 批量清理所有被控节点的 /var/log/old/ 下 7 天前的文件
ansible all -i inventory.ini -m shell -a "find /var/log/old/ -type f -mtime +7 -delete"
# 说明：
# -type f：仅清理文件（不删目录）
# -mtime +7：仅清理修改时间超过 7 天的文件
# -delete：直接删除（测试阶段可先替换为 -print，查看待删除文件列表）
步骤 2：在控制节点配置 Cron 定时任务
- 编辑 Cron 任务列表：
crontab -e - 添加定时任务（每天凌晨 3 点执行）：
# Ansible 定时清理被控节点旧日志（每天 03:00 执行） 0 3 * * * /usr/bin/ansible all -i /etc/ansible/inventory.ini -m shell -a "find /var/log/old/ -type f -mtime +7 -delete" >> /var/log/ansible_cron.log 2>&1- 参数说明：
0 3 * * *：Cron 时间表达式（分 时 日 月 周），表示每天凌晨 3 点；/usr/bin/ansible：Ansible 可执行文件路径（用which ansible查看）；>> /var/log/ansible_cron.log 2>&1：将执行日志输出到文件（便于排查问题）。
- 参数说明：
步骤 3：验证 Cron 任务
- 手动触发 Cron 任务（测试定时逻辑）：
bash
/usr/bin/ansible all -i /etc/ansible/inventory.ini -m shell -a "find /var/log/old/ -type f -mtime +7 -delete" >> /var/log/ansible_cron.log 2>&1 - 查看执行日志，确认无错误：
bash
cat /var/log/ansible_cron.log
五、总结与企业级扩展建议
5.1 本期核心收获
- K8s 集群管理：掌握用
k8s/kubectl模块实现 “节点初始化→资源部署→状态校验” 的自动化，解决多节点一致性问题； - 云资源管理：通过阿里云专属模块批量创建 ECS、配置安全组，替代手动控制台操作，提升云资源交付效率；
- 定时自动化：用 Ansible + Cron 快速实现重复任务的定时执行，减少运维人力投入。
5.2 企业级扩展建议
- 敏感信息加密：生产环境中，阿里云 AccessKey、数据库密码等敏感信息需用 Ansible Vault 加密，避免明文存储（参考第七期 “敏感信息加密” 内容）；
- 任务结果监控：将 Ansible 执行结果（如 ECS 创建成功 / 失败、日志清理数量）推送到 Prometheus/Grafana，实现可视化监控（参考第七期 “自动化监控” 内容）；
- Playbook 版本控制：用 Git 管理 Playbook 文件，记录变更历史，支持回滚，避免多人协作导致的配置混乱；
- 动态 Inventory：管理大规模云资源时，使用阿里云动态 Inventory（
aliyun_ecs插件），实时同步 ECS 实例列表，无需手动维护inventory.ini。
码道开发者社区，聚焦华为云码道 CodeArts 代码智能体，沉淀 Agent、Skill、鸿蒙开发实战内容，供开发者查阅资料、交流技术、分享工程实践
更多推荐
29
0- 0
已为社区贡献24条内容
所有评论(0)