引言:为什么选择Ansible进行数据备份与恢复
在现代企业IT运维中,数据安全是重中之重。传统的手动备份方式不仅效率低下,而且容易出错。Ansible作为一款强大的自动化工具,凭借其
无代理(Agentless)架构
、
简单易用的YAML语法
和
强大的模块生态系统
,成为实现自动化备份与恢复的理想选择。
Ansible在备份恢复领域的核心优势
跨平台支持
:支持Linux、Windows、网络设备等多种环境
幂等性
:确保备份任务可以安全重复执行
易于版本控制
:Playbook可以纳入Git管理,实现变更追溯
强大的集成能力
:可与rsync、tar、云存储等无缝集成
第一章:Ansible基础环境搭建
1.1 安装Ansible
在控制节点上安装Ansible(推荐使用Python 3.6+):
# Ubuntu/Debian
sudo apt update
sudo apt install software-properties-common
sudo add-apt-repository –yes –update ppa:ansible/ansible
sudo apt install ansible
# CentOS/RHEL
sudo yum install epel-release
sudo yum install ansible
# 验证安装
ansible –version
1.2 基础配置
创建Ansible配置文件和库存文件:
# 创建项目目录
mkdir -p /opt/ansible-backup/{playbooks,roles,files}
cd /opt/ansible-backup
# 创建ansible.cfg
cat > ansible.cfg << 'EOF'
[defaults]
inventory = ./hosts
remote_user = ansible
private_key_file = ~/.ssh/id_rsa
host_key_checking = False
retry_files_enabled = False
log_path = ./ansible.log
EOF
# 创建库存文件
cat > hosts << 'EOF'
[web_servers]
web1 ansible_host=192.168.1.101
web2 ansible_host=192.168.1.102
[db_servers]
db1 ansible_host=192.168.1.201
db2 ansible_host=192.168.1.202
[backup_server]
backup ansible_host=192.168.1.10
EOF
1.3 准备测试环境
为了安全起见,我们先创建一个测试目录结构:
# 在控制节点创建测试数据
sudo mkdir -p /var/www/html
sudo chown ansible:ansible /var/www/html
echo "Test website data" > /var/www/html/index.html
echo “Config file” > /var/www/html/config.php
# 创建数据库备份测试目录
sudo mkdir -p /var/lib/mysql/backup
sudo chown ansible:ansible /var/lib/mysql/backup
echo “Database dump” > /var/lib/mysql/backup/test.sql
第二章:Ansible备份策略设计
2.1 备份类型与场景
企业级备份通常包括:
文件系统备份
:网站代码、配置文件、用户数据
数据库备份
:MySQL、PostgreSQL等
系统配置备份
:系统参数、用户权限等
2.2 备份存储策略
本地备份
:快速恢复,但存在单点故障风险
远程备份
:异地容灾,但受网络带宽限制
云存储备份
:高可用性,但需要考虑成本
第三章:文件系统备份实战
3.1 使用archive模块创建增量备份
# playbooks/backup_files.yml
—
– name: 备份Web服务器文件
hosts: web_servers
become: yes
vars:
backup_src: /var/www/html
backup_dest: /backup/web
backup_retention_days: 7
timestamp: “{{ ansible_date_time.epoch }}”
tasks:
– name: 确保备份目录存在
file:
path: “{{ backup_dest }}”
state: directory
mode: ‘0755’
– name: 创建时间戳目录
file:
path: “{{ backup_dest }}/{{ timestamp }}”
state: directory
mode: ‘0755’
– name: 打包源文件
archive:
path: “{{ backup_src }}”
dest: “{{ backup_dest }}/{{ timestamp }}/web_backup.tar.gz”
format: gz
exclude_path:
– “{{ backup_src }}/cache”
– “{{ backup_src }}/tmp”
register: archive_result
– name: 生成备份清单
copy:
content: |
Backup Time: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
Source: {{ backup_src }}
Files: {{ archive_result.archived | length }}
Size: {{ archive_result.size }}
dest: “{{ backup_dest }}/{{ timestamp }}/backup_info.txt”
– name: 清理旧备份(保留最近7天)
shell: |
find {{ backup_dest }} -type d -mtime +{{ backup_retention_days }} -exec rm -rf {} +
when: backup_retention_days > 0
register: cleanup_result
– name: 显示清理结果
debug:
msg: “已清理旧备份: {{ cleanup_result.stdout_lines }}”
when: cleanup_result.stdout_lines | length > 0
3.2 使用rsync进行实时同步备份
# playbooks/sync_backup.yml
—
– name: 实时同步备份到备份服务器
hosts: web_servers
become: yes
vars:
source_dir: /var/www/html
backup_user: backup
backup_host: 192.168.1.10
backup_path: /backup/web/sync
tasks:
– name: 确保SSH密钥已配置
authorized_key:
user: “{{ backup_user }}”
key: “{{ lookup(‘file’, ‘~/.ssh/id_rsa.pub’) }}”
delegate_to: “{{ backup_host }}”
– name: 使用rsync同步文件
shell: |
rsync -avz –delete \
-e “ssh -o StrictHostKeyChecking=no” \
{{ source_dir }}/ \
{{ backup_user }}@{{ backup_host }}:{{ backup_path }}/
register: sync_result
– name: 显示同步状态
debug:
msg: “同步完成: {{ sync_result.stdout_lines[-1] }}”
3.3 增量备份策略实现
# playbooks/incremental_backup.yml
—
– name: 增量备份策略
hosts: web_servers
become: yes
vars:
base_backup_dir: /backup/web/incremental
full_backup_day: “Sunday” # 每周日全量备份
incremental_backup_days: [“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”]
tasks:
– name: 获取当前星期
set_fact:
current_day: “{{ ansible_date_time.day_name }}”
– name: 执行全量备份
block:
– name: 创建全量备份
archive:
path: /var/www/html
dest: “{{ base_backup_dir }}/full_{{ ansible_date_time.date }}.tar.gz”
format: gz
when: current_day == full_backup_day
– name: 执行增量备份
block:
– name: 查找上次备份后的变更文件
find:
paths: /var/www/html
recurse: yes
age: 86400 # 24小时内变更
age_stamp: mtime
register: changed_files
– name: 创建增量备份
archive:
path: “{{ changed_files.files | map(attribute=’path’) | list }}”
dest: “{{ base_backup_dir }}/inc_{{ ansible_date_time.date }}.tar.gz”
format: gz
when: changed_files.files | length > 0
when: current_day != full_backup_day
第四章:数据库备份实战
4.1 MySQL数据库备份
# playbooks/backup_mysql.yml
—
– name: MySQL数据库备份
hosts: db_servers
become: yes
vars:
db_user: root
db_pass: “{{ vault_db_password }}”
db_name: all
backup_dir: /backup/mysql
timestamp: “{{ ansible_date_time.date }}_{{ ansible_date_time.hour }}{{ ansible_date_time.minute }}”
tasks:
– name: 确保备份目录存在
file:
path: “{{ backup_dir }}”
state: directory
mode: ‘0700’
– name: 备份所有数据库
mysql_db:
name: “{{ db_name }}”
state: dump
target: “{{ backup_dir }}/mysql_full_{{ timestamp }}.sql”
login_user: “{{ db_user }}”
login_password: “{{ db_pass }}”
register: backup_result
– name: 压缩备份文件
archive:
path: “{{ backup_dir }}/mysql_full_{{ timestamp }}.sql”
dest: “{{ backup_dir }}/mysql_full_{{ timestamp }}.sql.gz”
format: gz
– name: 删除未压缩的SQL文件
file:
path: “{{ backup_dir }}/mysql_full_{{ timestamp }}.sql”
state: absent
– name: 生成备份信息
copy:
content: |
Database: {{ db_name }}
Time: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
Size: {{ backup_result.size }}
Status: {{ backup_result.changed }}
dest: “{{ backup_dir }}/mysql_full_{{ timestamp }}.info”
– name: 限制备份文件数量(保留最近10个)
shell: |
ls -t {{ backup_dir }}/mysql_full_*.sql.gz | tail -n +11 | xargs rm -f
ignore_errors: yes
4.2 PostgreSQL数据库备份
# playbooks/backup_postgresql.yml
—
– name: PostgreSQL数据库备份
hosts: db_servers
become: yes
become_user: postgres
vars:
backup_dir: /backup/postgresql
timestamp: “{{ ansible_date_time.date }}_{{ ansible_date_time.hour }}{{ ansible_date_time.minute }}”
tasks:
– name: 确保备份目录存在
file:
path: “{{ backup_dir }}”
state: directory
mode: ‘0700’
– name: 备份所有数据库
shell: |
pg_dumpall –clean –if-exists > {{ backup_dir }}/pg_full_{{ timestamp }}.sql
register: backup_result
– name: 压缩备份文件
archive:
path: “{{ backup_dir }}/pg_full_{{ timestamp }}.sql”
dest: “{{ backup_dir }}/pg_full_{{ timestamp }}.sql.gz”
format: gz
– name: 删除未压缩的SQL文件
file:
path: “{{ backup_dir }}/pg_full_{{ timestamp }}.sql”
state: absent
– name: 设置备份文件权限
file:
path: “{{ backup_dir }}/pg_full_{{ timestamp }}.sql.gz”
mode: ‘0600’
owner: postgres
group: postgres
4.3 MongoDB数据库备份
# playbooks/backup_mongodb.yml
—
– name: MongoDB数据库备份
hosts: db_servers
become: yes
vars:
backup_dir: /backup/mongodb
timestamp: “{{ ansible_date_time.date }}_{{ ansible_date_time.hour }}{{ ansible_date_time.minute }}”
mongo_db: myapp
tasks:
– name: 确保备份目录存在
file:
path: “{{ backup_dir }}”
state: directory
mode: ‘0700’
– name: 执行MongoDB备份
shell: |
mongodump –db {{ mongo_db }} –out {{ backup_dir }}/dump_{{ timestamp }}
register: backup_result
– name: 压缩备份目录
archive:
path: “{{ backup_dir }}/dump_{{ timestamp }}”
dest: “{{ backup_dir }}/mongodb_{{ timestamp }}.tar.gz”
format: gz
– name: 清理临时目录
file:
path: “{{ backup_dir }}/dump_{{ timestamp }}”
state: absent
– name: 限制备份文件数量
shell: |
ls -t {{ backup_dir }}/mongodb_*.tar.gz | tail -n +6 | xargs rm -f
ignore_errors: yes
第五章:高级备份策略
5.1 备份到云存储(AWS S3)
# playbooks/backup_to_s3.yml
—
– name: 备份到AWS S3
hosts: localhost
connection: local
vars:
s3_bucket: my-backup-bucket
s3_region: us-east-1
local_backup_dir: /backup/web
retention_days: 30
tasks:
– name: 安装boto3(如果未安装)
pip:
name: boto3
state: present
– name: 同步本地备份到S3
aws_s3:
bucket: “{{ s3_bucket }}”
src: “{{ local_backup_dir }}/”
dest: “web-backups/”
mode: put
permission: private
overwrite: different
register: sync_result
– name: 清理S3中的旧备份
community.aws.s3_lifecycle:
bucket: “{{ s3_bucket }}”
name: “backup-retention”
prefix: “web-backups/”
status: enabled
expiration_days: “{{ retention_days }}”
state: present
– name: 生成S3同步报告
copy:
content: |
S3 Sync Report
==============
Date: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
Bucket: {{ s3_bucket }}
Files Synced: {{ sync_result.changed }}
Total Size: {{ sync_result.size }}
dest: “{{ local_backup_dir }}/s3_sync_report_{{ ansible_date_time.date }}.txt”
5.2 加密备份文件
# playbooks/encrypted_backup.yml
—
– name: 创建加密备份
hosts: web_servers
become: yes
vars:
backup_src: /var/www/html
backup_dest: /backup/encrypted
encryption_key: “{{ lookup(‘env’, ‘BACKUP_ENCRYPTION_KEY’) }}”
tasks:
– name: 确保备份目录存在
file:
path: “{{ backup_dest }}”
state: directory
mode: ‘0700’
– name: 创建临时打包文件
archive:
path: “{{ backup_src }}”
dest: “/tmp/web_backup_{{ ansible_date_time.epoch }}.tar.gz”
format: gz
– name: 使用GPG加密备份文件
shell: |
echo “{{ encryption_key }}” | gpg –batch –yes –passphrase-fd 0 \
–symmetric –cipher-algo AES256 \
–output {{ backup_dest }}/web_backup_{{ ansible_date_time.epoch }}.tar.gz.gpg \
/tmp/web_backup_{{ ansible_date_time.epoch }}.tar.gz
no_log: true
– name: 删除临时文件
file:
path: “/tmp/web_backup_{{ ansible_date_time.epoch }}.tar.gz”
state: absent
– name: 生成解密说明
copy:
content: |
解密命令:
gpg –decrypt –batch –passphrase “{{ encryption_key }}” \
web_backup_{{ ansible_date_time.epoch }}.tar.gz.gpg > backup.tar.gz
dest: “{{ backup_dest }}/decrypt_instructions_{{ ansible_date_time.epoch }}.txt”
mode: ‘0600’
5.3 备份验证与完整性检查
# playbooks/verify_backup.yml
—
– name: 验证备份完整性
hosts: localhost
connection: local
vars:
backup_dir: /backup/web
test_restore_dir: /tmp/restore_test
tasks:
– name: 获取最新的备份文件
find:
paths: “{{ backup_dir }}”
patterns: “*.tar.gz”
sort: “mtime”
register: backup_files
– name: 选择最新备份
set_fact:
latest_backup: “{{ backup_files.files[0].path }}”
– name: 创建测试恢复目录
file:
path: “{{ test_restore_dir }}”
state: directory
mode: ‘0755’
– name: 解压备份到测试目录
unarchive:
src: “{{ latest_backup }}”
dest: “{{ test_restore_dir }}”
remote_src: yes
– name: 验证关键文件存在
stat:
path: “{{ test_restore_dir }}/var/www/html/index.html”
register: index_file
– name: 检查文件完整性
fail:
msg: “备份验证失败:关键文件不存在”
when: not index_file.stat.exists
– name: 计算文件哈希值进行验证
shell: |
find {{ test_restore_dir }} -type f -exec sha256sum {} \; | sort > /tmp/restore_hash.txt
find /var/www/html -type f -exec sha256sum {} \; | sort > /tmp/original_hash.txt
diff /tmp/restore_hash.txt /tmp/original_hash.txt
register: hash_check
ignore_errors: yes
– name: 显示验证结果
debug:
msg: “备份验证成功,文件完整性良好”
when: hash_check.rc == 0
– name: 清理测试目录
file:
path: “{{ test_restore_dir }}”
state: absent
第六章:自动化恢复策略
6.1 文件系统恢复
# playbooks/restore_files.yml
—
– name: 恢复文件系统备份
hosts: web_servers
become: yes
vars:
backup_dir: /backup/web
restore_target: /var/www/html
restore_point: “latest” # 或指定时间戳
tasks:
– name: 确定要恢复的备份
find:
paths: “{{ backup_dir }}”
patterns: “*.tar.gz”
sort: “mtime”
register: backup_files
– name: 选择恢复点
set_fact:
restore_file: “{% if restore_point == ‘latest’ %}{{ backup_files.files[0].path }}{% else %}{{ backup_dir }}/{{ restore_point }}.tar.gz{% endif %}”
– name: 验证备份文件存在
stat:
path: “{{ restore_file }}”
register: backup_stat
– name: 备份当前数据(安全措施)
archive:
path: “{{ restore_target }}”
dest: “/tmp/pre_restore_backup_{{ ansible_date_time.epoch }}.tar.gz”
format: gz
when: backup_stat.stat.exists
– name: 清空目标目录
file:
path: “{{ restore_target }}”
state: absent
when: backup_stat.stat.exists
– name: 创建目标目录
file:
path: “{{ restore_target }}”
state: directory
mode: ‘0755’
when: backup_stat.stat.exists
– name: 解压备份文件
unarchive:
src: “{{ restore_file }}”
dest: “/”
remote_src: yes
when: backup_stat.stat.exists
– name: 恢复文件权限
file:
path: “{{ restore_target }}”
state: directory
owner: www-data
group: www-data
mode: ‘0755’
recurse: yes
when: backup_stat.stat.exists
– name: 验证恢复结果
stat:
path: “{{ restore_target }}/index.html”
register: restored_file
– name: 报告恢复状态
debug:
msg: “恢复成功!文件: {{ restore_target }}/index.html”
when: restored_file.stat.exists
– name: 恢复失败处理
fail:
msg: “恢复失败,请检查备份文件”
when: not backup_stat.stat.exists
6.2 数据库恢复
# playbooks/restore_mysql.yml
—
– name: 恢复MySQL数据库
hosts: db_servers
become: yes
vars:
backup_dir: /backup/mysql
restore_file: “latest” # 或指定文件名
db_user: root
db_pass: “{{ vault_db_password }}”
target_db: myapp
tasks:
– name: 确定要恢复的备份文件
find:
paths: “{{ backup_dir }}”
patterns: “mysql_full_*.sql.gz”
sort: “mtime”
register: backup_files
– name: 选择恢复文件
set_fact:
restore_file_path: “{% if restore_file == ‘latest’ %}{{ backup_files.files[0].path }}{% else %}{{ backup_dir }}/{{ restore_file }}{% endif %}”
– name: 验证备份文件存在
stat:
path: “{{ restore_file_path }}”
register: backup_stat
– name: 创建临时解压目录
tempfile:
state: directory
suffix: _restore
register: temp_dir
when: backup_stat.stat.exists
– name: 解压备份文件到临时目录
unarchive:
src: “{{ restore_file_path }}”
dest: “{{ temp_dir.path }}”
remote_src: yes
when: backup_stat.stat.exists
– name: 查找解压后的SQL文件
find:
paths: “{{ temp_dir.path }}”
patterns: “*.sql”
register: sql_files
when: backup_stat.stat.exists
– name: 停止应用服务(可选)
service:
name: apache2
state: stopped
ignore_errors: yes
when: backup_stat.stat.exists
– name: 恢复数据库
mysql_db:
name: “{{ target_db }}”
state: import
target: “{{ sql_files.files[0].path }}”
login_user: “{{ db_user }}”
login_password: “{{ db_pass }}”
when: backup_stat.stat.exists
– name: 启动应用服务
service:
name: apache2
state: started
when: backup_stat.stat.exists
– name: 清理临时文件
file:
path: “{{ temp_dir.path }}”
state: absent
when: temp_dir.path is defined
– name: 验证数据库恢复
shell: |
mysql -u {{ db_user }} -p{{ db_pass }} -e “SELECT COUNT(*) FROM {{ target_db }}.users”
register: db_check
ignore_errors: yes
when: backup_stat.stat.exists
– name: 显示恢复结果
debug:
msg: “数据库恢复完成,表记录数: {{ db_check.stdout }}”
when: db_check.rc == 0
6.3 灾难恢复场景
# playbooks/disaster_recovery.yml
—
– name: 灾难恢复 – 完整流程
hosts: localhost
connection: local
vars:
new_server_ip: “192.168.1.210”
backup_server: “192.168.1.10”
web_backup_path: “/backup/web/latest.tar.gz”
db_backup_path: “/backup/mysql/latest.sql.gz”
ssh_key: “~/.ssh/id_rsa”
tasks:
– name: 等待新服务器上线
wait_for:
host: “{{ new_server_ip }}”
port: 22
timeout: 300
– name: 传输Web备份到新服务器
shell: |
scp -i {{ ssh_key }} {{ backup_server }}:{{ web_backup_path }} /tmp/web_restore.tar.gz
scp -i {{ ssh_key }} /tmp/web_restore.tar.gz root@{{ new_server_ip }}:/tmp/
– name: 传输数据库备份到新服务器
shell: |
scp -i {{ ssh_key }} {{ backup_server }}:{{ db_backup_path }} /tmp/db_restore.sql.gz
scp -i {{ ssh_key }} /tmp/db_restore.sql.gz root@{{ new_server_ip }}:/tmp/
– name: 在新服务器上执行恢复
shell: |
ssh -i {{ ssh_key }} root@{{ new_server_ip }} << 'EOF'
# 恢复Web文件
mkdir -p /var/www/html
tar -xzf /tmp/web_restore.tar.gz -C /
# 恢复数据库
gunzip /tmp/db_restore.sql.gz
mysql -u root -p'{{ vault_db_password }}' < /tmp/db_restore.sql
# 设置权限
chown -R www-data:www-data /var/www/html
chmod -R 755 /var/www/html
# 清理
rm -f /tmp/web_restore.tar.gz /tmp/db_restore.sql
EOF
register: recovery_result
- name: 验证恢复结果
uri:
url: "http://{{ new_server_ip }}"
return_content: yes
register: web_test
- name: 生成灾难恢复报告
copy:
content: |
Disaster Recovery Report
=======================
Date: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
New Server: {{ new_server_ip }}
Web Restore: {{ 'SUCCESS' if web_test.status == 200 else 'FAILED' }}
DB Restore: {{ 'SUCCESS' if recovery_result.rc == 0 else 'FAILED' }}
Test Result: {{ web_test.status }}
dest: "/tmp/disaster_recovery_report_{{ ansible_date_time.date }}.txt"
第七章:监控与告警
7.1 备份状态监控
# playbooks/backup_monitoring.yml
---
- name: 备份状态监控
hosts: localhost
connection: local
vars:
backup_dirs:
- /backup/web
- /backup/mysql
alert_email: "admin@example.com"
max_age_hours: 25 # 25小时内应有新备份
tasks:
- name: 检查各备份目录
find:
paths: "{{ item }}"
patterns: "*"
age: "{{ max_age_hours * 3600 }}"
age_stamp: mtime
register: backup_checks
loop: "{{ backup_dirs }}"
- name: 识别过期备份
set_fact:
expired_backups: "{{ backup_checks.results | selectattr('matched', 'equalto', 0) | map(attribute='item') | list }}"
- name: 发送告警邮件(需要配置邮件服务器)
mail:
to: "{{ alert_email }}"
subject: "备份告警 - 过期备份检测"
body: |
检测到过期备份目录:
{% for dir in expired_backups %}
- {{ dir }}
{% endfor %}
检测时间: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
期望备份周期: {{ max_age_hours }} 小时
when: expired_backups | length > 0
delegate_to: localhost
– name: 生成监控报告
copy:
content: |
Backup Monitoring Report
========================
Date: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
Checked Directories:
{% for result in backup_checks.results %}
– {{ result.item }}: {{ result.matched }} files found
{% endfor %}
Expired Backups: {{ expired_backups | length }}
Status: {{ ‘WARNING’ if expired_backups | length > 0 else ‘OK’ }}
dest: “/tmp/backup_monitor_{{ ansible_date_time.date }}.txt”
7.2 备份性能监控
# playbooks/backup_performance.yml
—
– name: 备份性能监控
hosts: web_servers,db_servers
become: yes
vars:
backup_log_dir: /var/log/backup
alert_threshold: 300 # 5分钟
tasks:
– name: 确保日志目录存在
file:
path: “{{ backup_log_dir }}”
state: directory
mode: ‘0755’
– name: 执行备份并记录性能
shell: |
time (tar -czf /tmp/perf_test.tar.gz /var/www/html 2>&1) 2> {{ backup_log_dir }}/perf_{{ ansible_date_time.epoch }}.log
register: perf_result
– name: 解析执行时间
shell: |
grep real {{ backup_log_dir }}/perf_{{ ansible_date_time.epoch }}.log | awk ‘{print $2}’
register: exec_time
– name: 记录性能数据
copy:
content: |
Timestamp: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
Execution Time: {{ exec_time.stdout }}
Host: {{ inventory_hostname }}
dest: “{{ backup_log_dir }}/performance_{{ ansible_date_time.epoch }}.log”
– name: 性能告警
debug:
msg: “警告:备份执行时间过长 – {{ exec_time.stdout }}”
when: exec_time.stdout | float > alert_threshold
第八章:最佳实践与优化
8.1 使用Roles组织代码
# 创建角色结构
mkdir -p roles/{backup,restore}/{tasks,handlers,templates,files,defaults,meta}
# roles/backup/defaults/main.yml
—
backup_dest: /backup
backup_src: /var/www/html
backup_retention_days: 7
backup_schedule: daily
backup_compress: true
backup_encrypt: false
backup_notify_email: admin@example.com
# roles/backup/tasks/main.yml
—
– name: 确保备份目录存在
file:
path: “{{ backup_dest }}”
state: directory
mode: ‘0755’
– name: 执行备份
include_tasks: “{{ backup_schedule }}_backup.yml”
when: backup_schedule in [‘daily’, ‘weekly’, ‘monthly’]
– name: 清理旧备份
include_tasks: cleanup.yml
– name: 发送通知
include_tasks: notify.yml
when: backup_notify_email is defined
8.2 使用Ansible Vault保护敏感数据
# 创建加密文件
ansible-vault create group_vars/all/vault.yml
# vault.yml 内容(加密后)
vault_db_password: “super_secret_db_pass”
vault_aws_access_key: “AKIAIOSFODNN7EXAMPLE”
vault_aws_secret_key: “wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY”
vault_gpg_passphrase: “backup_encryption_key”
# 在playbook中使用vault变量
– name: 使用加密变量
mysql_db:
login_password: “{{ vault_db_password }}”
8.3 备份策略优化建议
分层备份
:
本地快速备份(最近24小时)
远程归档备份(最近7天)
云存储长期备份(最近90天)
带宽优化
:
“`yaml
使用压缩和增量传输
name: 增量rsync备份
shell: |
rsync -avz –partial –progress
–link-dest=/backup/web/previous
/var/www/html/ backup@server:/backup/web/current/
”`
资源限制
:
“`yaml
限制备份带宽(10MB/s)
name: 限速备份
shell: |
rsync –bwlimit=10000 /var/www/html/ backup@server:/backup/
”`
第九章:企业级部署方案
9.1 使用AWX/Tower实现Web界面管理
# AWX配置示例
—
– name: 配置AWX备份作业
awx.awx.job_template:
name: “Daily Backup”
job_type: run
inventory: “Production”
project: “Backup Playbooks”
playbook: “playbooks/backup_all.yml”
credential: “SSH Key”
execution_environment: “Backup Environment”
webhook_service: “slack”
webhook_url: “https://hooks.slack.com/services/YOUR/WEBHOOK/URL”
9.2 CI/CD集成
# .gitlab-ci.yml
stages:
– backup
daily_backup:
stage: backup
script:
– ansible-playbook playbooks/backup_all.yml –vault-password-file .vault_pass
only:
– schedules
artifacts:
paths:
– backup_reports/
expire_in: 90 days
9.3 容器化部署
# Dockerfile
FROM python:3.9-slim
RUN apt-get update && apt-get install -y \
ansible \
mysql-client \
postgresql-client \
mongodb-tools \
rsync \
openssh-client \
gnupg \
&& rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install -r requirements.txt
WORKDIR /ansible
COPY . .
CMD [“ansible-playbook”, “–version”]
第十章:故障排查与维护
10.1 常见问题解决
# playbooks/troubleshoot.yml
—
– name: 备份故障排查
hosts: all
become: yes
tasks:
– name: 检查磁盘空间
shell: df -h /backup
register: disk_space
– name: 检查备份目录权限
file:
path: /backup
state: directory
mode: ‘0755’
owner: root
group: root
– name: 测试数据库连接
mysql_db:
login_user: root
login_password: “{{ vault_db_password }}”
name: test
state: present
ignore_errors: yes
register: db_test
– name: 生成诊断报告
copy:
content: |
Diagnostic Report
=================
Disk Space: {{ disk_space.stdout }}
DB Connection: {{ ‘OK’ if db_test.rc == 0 else ‘FAILED’ }}
Timestamp: {{ ansible_date_time.date }} {{ ansible_date_time.time }}
dest: “/tmp/diagnostic_{{ ansible_date_time.epoch }}.txt”
10.2 日志分析
# 分析Ansible日志
grep -E “(FAILED|ERROR|changed=true)” /opt/ansible-backup/ansible.log
# 监控备份文件大小变化
ls -lh /backup/web/ | awk ‘{print $5, $9}’ > backup_size_history.txt
结论
通过本指南,您已经掌握了使用Ansible实现企业级数据备份与恢复的完整方案。关键要点包括:
自动化优先
:减少人为错误,提高效率
多重备份
:本地+远程+云存储的3-2-1策略
定期验证
:确保备份可恢复
安全第一
:使用加密和权限控制
持续监控
:及时发现和解决问题
建议从简单的文件备份开始,逐步扩展到数据库和复杂场景。定期测试恢复流程,确保在真正需要时能够快速恢复数据。
下一步行动清单
[ ] 在测试环境验证所有playbook
[ ] 配置Ansible Vault加密敏感数据
[ ] 设置cron定时任务
[ ] 配置监控告警
[ ] 编写恢复流程文档
[ ] 定期进行灾难恢复演练
记住:
没有经过测试的备份等于没有备份
。确保您的备份策略在实际灾难发生前已经过充分验证。