全面掌握Ansible集群管理脚本编写从入门到精通的实用指南让运维工作更高效轻松应对大规模服务器集群管理挑战提升自动化水平

威震华夏关云长

引言

在当今快速发展的IT环境中，运维团队面临着管理成百上千台服务器的巨大挑战。手动管理这些服务器不仅效率低下，而且容易出错。Ansible作为一款强大的自动化工具，以其简单易用、无代理架构和强大的功能，成为了运维工程师的首选工具。本文将带您从零开始，逐步掌握Ansible集群管理脚本编写的精髓，帮助您提升自动化水平，轻松应对大规模服务器集群管理挑战。

Ansible基础概念

什么是Ansible

Ansible是一款开源的IT自动化工具，它可以帮助您自动化应用程序部署、配置管理、云服务预置和网络编排等任务。与其他自动化工具相比，Ansible的最大优势在于其简单性和无代理架构。

核心组件

Ansible由几个核心组件构成，理解这些组件是掌握Ansible的第一步：

• 控制节点（Control Node）：安装Ansible并运行Ansible命令的机器。
• 受管节点（Managed Node）：被Ansible管理的服务器或设备。
• 清单（Inventory）：定义受管节点的文件，可以是静态的也可以是动态生成的。
• 模块（Modules）：Ansible执行任务的工具，每个模块都有特定的功能。
• Playbook：使用YAML语言编写的文件，定义了一系列要执行的任务。
• 角色（Roles）：组织Playbook的一种方式，使复杂的自动化任务更加结构化和可重用。

Ansible工作原理

Ansible通过SSH连接到受管节点，并在这些节点上执行模块。由于不需要在受管节点上安装任何特殊的代理软件，Ansible的部署和使用变得非常简单。控制节点将模块推送到受管节点，模块执行完成后将结果返回给控制节点。整个过程是幂等的，意味着无论运行多少次，结果都是一致的。

环境搭建

安装Ansible

在开始使用Ansible之前，我们需要在控制节点上安装Ansible。以下是不同操作系统上的安装方法：

2. # 安装EPEL仓库
3. sudo yum install epel-release -y
5. # 安装Ansible
6. sudo yum install ansible -y

复制代码

2. # 更新包索引
3. sudo apt update
5. # 安装Ansible
6. sudo apt install ansible -y

复制代码

2. # 安装pip
3. sudo apt install python3-pip -y  # Ubuntu/Debian
4. sudo yum install python3-pip -y  # CentOS/RHEL
6. # 使用pip安装Ansible
7. pip3 install ansible

复制代码

配置SSH免密登录

Ansible通过SSH连接到受管节点，因此需要配置SSH免密登录以实现自动化操作：

2. # 生成SSH密钥（如果还没有）
3. ssh-keygen -t rsa
5. # 将公钥复制到受管节点
6. ssh-copy-id user@managed_node_ip

复制代码

创建Ansible配置文件

Ansible的配置文件通常位于/etc/ansible/ansible.cfg，您也可以在项目目录中创建自定义的配置文件。以下是一个基本的配置示例：

2. [defaults]
3. inventory = ./inventory
4. host_key_checking = False
5. remote_user = ansible
6. private_key_file = ~/.ssh/id_rsa

复制代码

基础入门

创建清单文件

清单文件定义了Ansible要管理的主机。以下是一个简单的静态清单文件示例：

2. [web_servers]
3. web1.example.com
4. web2.example.com
6. [db_servers]
7. db1.example.com
8. db2.example.com
10. [all:vars]
11. ansible_ssh_user=ansible

复制代码

您也可以使用YAML格式的清单文件：

2. all:
3.   hosts:
4.     web1.example.com:
5.     web2.example.com:
6.   children:
7.     web_servers:
8.       hosts:
9.         web1.example.com:
10.         web2.example.com:
11.     db_servers:
12.       hosts:
13.         db1.example.com:
14.         db2.example.com:
15.   vars:
16.     ansible_ssh_user: ansible

复制代码

使用Ad-hoc命令

Ad-hoc命令是Ansible的快速执行方式，适合执行简单的任务。以下是一些常用的Ad-hoc命令示例：

2. # 检查所有主机的连通性
3. ansible all -m ping
5. # 在web_servers组上安装nginx
6. ansible web_servers -m yum -a "name=nginx state=present"
8. # 重启db_servers组上的mysql服务
9. ansible db_servers -m service -a "name=mysql state=restarted"
11. # 在所有主机上执行命令
12. ansible all -m command -a "date"

复制代码

编写第一个Playbook

Playbook是Ansible的核心，它使用YAML语言定义了一系列任务。以下是一个简单的Playbook示例，用于在web服务器上安装和启动nginx：

2. ---
3. - name: Install and start nginx
4.   hosts: web_servers
5.   become: yes
6.   
7.   tasks:
8.     - name: Install nginx
9.       yum:
10.         name: nginx
11.         state: present
12.    
13.     - name: Start nginx service
14.       service:
15.         name: nginx
16.         state: started
17.         enabled: yes

复制代码

运行Playbook：

2. ansible-playbook install_nginx.yml

复制代码

进阶技巧

使用变量

变量使Playbook更加灵活和可重用。您可以在多个地方定义变量：

2. ---
3. - name: Install and start nginx
4.   hosts: web_servers
5.   become: yes
6.   vars:
7.     nginx_version: 1.18.0
8.   
9.   tasks:
10.     - name: Install specific version of nginx
11.       yum:
12.         name: nginx-{{ nginx_version }}
13.         state: present

复制代码

创建一个变量文件vars.yml：

2. nginx_version: 1.18.0
3. nginx_port: 8080

复制代码

在Playbook中引用变量文件：

2. ---
3. - name: Install and configure nginx
4.   hosts: web_servers
5.   become: yes
6.   vars_files:
7.     - vars.yml
8.   
9.   tasks:
10.     - name: Install nginx
11.       yum:
12.         name: nginx-{{ nginx_version }}
13.         state: present
14.    
15.     - name: Configure nginx port
16.       template:
17.         src: nginx.conf.j2
18.         dest: /etc/nginx/nginx.conf
19.       notify: Restart nginx
20.   
21.   handlers:
22.     - name: Restart nginx
23.       service:
24.         name: nginx
25.         state: restarted

复制代码

您可以在清单文件目录中创建host_vars和group_vars目录来为特定主机或组定义变量：

2. inventory/
3. ├── group_vars/
4. │   ├── web_servers.yml
5. │   └── db_servers.yml
6. ├── host_vars/
7. │   ├── web1.example.com.yml
8. │   └── web2.example.com.yml
9. └── hosts

复制代码

使用模板

Ansible使用Jinja2模板引擎来生成配置文件。以下是一个nginx配置模板示例：

2. # nginx.conf.j2
3. user nginx;
4. worker_processes {{ ansible_processor_vcpus }};
5. error_log /var/log/nginx/error.log;
6. pid /run/nginx.pid;
8. events {
9.     worker_connections 1024;
10. }
12. http {
13.     log_format main '$remote_addr - $remote_user [$time_local] "$request" '
14.                     '$status $body_bytes_sent "$http_referer" '
15.                     '"$http_user_agent" "$http_x_forwarded_for"';
17.     access_log /var/log/nginx/access.log main;
19.     sendfile on;
20.     tcp_nopush on;
21.     tcp_nodelay on;
22.     keepalive_timeout 65;
23.     types_hash_max_size 2048;
25.     include /etc/nginx/mime.types;
26.     default_type application/octet-stream;
28.     include /etc/nginx/conf.d/*.conf;
30.     server {
31.         listen {{ nginx_port }};
32.         server_name _;
34.         location / {
35.             root /usr/share/nginx/html;
36.             index index.html;
37.         }
38.     }
39. }

复制代码

条件判断和循环

使用when语句来实现条件执行：

2. ---
3. - name: Configure web servers
4.   hosts: web_servers
5.   become: yes
6.   
7.   tasks:
8.     - name: Install Apache on CentOS
9.       yum:
10.         name: httpd
11.         state: present
12.       when: ansible_os_family == "RedHat"
13.    
14.     - name: Install Apache on Ubuntu
15.       apt:
16.         name: apache2
17.         state: present
18.       when: ansible_os_family == "Debian"

复制代码

使用loop或with_items来重复执行任务：

2. ---
3. - name: Install multiple packages
4.   hosts: web_servers
5.   become: yes
6.   
7.   tasks:
8.     - name: Install required packages
9.       package:
10.         name: "{{ item }}"
11.         state: present
12.       loop:
13.         - nginx
14.         - git
15.         - htop

复制代码

错误处理

使用ignore_errors来忽略任务失败：

2. ---
3. - name: Example with error handling
4.   hosts: web_servers
5.   become: yes
6.   
7.   tasks:
8.     - name: This task might fail
9.       command: /bin/false
10.       ignore_errors: yes
11.    
12.     - name: This task will run regardless
13.       debug:
14.         msg: "This task runs even if the previous one failed"

复制代码

使用failed_when来定义任务失败的条件：

2. ---
3. - name: Check disk space
4.   hosts: all
5.   become: yes
6.   
7.   tasks:
8.     - name: Get disk usage
9.       command: df -h /
10.       register: disk_usage
11.    
12.     - name: Fail if disk space is low
13.       fail:
14.         msg: "Disk space is too low"
15.       when: "'90%' in disk_usage.stdout"

复制代码

使用角色

角色是组织Playbook的一种方式，使复杂的自动化任务更加结构化和可重用。以下是一个角色的基本结构：

2. roles/
3. └── nginx/
4.     ├── defaults/
5.     │   └── main.yml
6.     ├── files/
7.     ├── handlers/
8.     │   └── main.yml
9.     ├── meta/
10.     │   └── main.yml
11.     ├── tasks/
12.     │   └── main.yml
13.     ├── templates/
14.     ├── tests/
15.     │   └── inventory
16.     └── vars/
17.         └── main.yml

复制代码

1. 创建角色目录结构：

2. mkdir -p roles/nginx/{tasks,handlers,templates,vars,defaults,meta}

复制代码

1. 定义任务（roles/nginx/tasks/main.yml）：

2. ---
3. - name: Install nginx
4.   package:
5.     name: nginx
6.     state: present
8. - name: Create nginx config
9.   template:
10.     src: nginx.conf.j2
11.     dest: /etc/nginx/nginx.conf
12.   notify: Restart nginx
14. - name: Start nginx service
15.   service:
16.     name: nginx
17.     state: started
18.     enabled: yes

复制代码

1. 定义处理器（roles/nginx/handlers/main.yml）：

2. ---
3. - name: Restart nginx
4.   service:
5.     name: nginx
6.     state: restarted

复制代码

1. 创建模板文件（roles/nginx/templates/nginx.conf.j2）：

2. user nginx;
3. worker_processes {{ ansible_processor_vcpus }};
4. error_log /var/log/nginx/error.log;
5. pid /run/nginx.pid;
7. events {
8.     worker_connections 1024;
9. }
11. http {
12.     include /etc/nginx/mime.types;
13.     default_type application/octet-stream;
15.     sendfile on;
16.     tcp_nopush on;
17.     tcp_nodelay on;
18.     keepalive_timeout 65;
19.     types_hash_max_size 2048;
21.     include /etc/nginx/conf.d/*.conf;
23.     server {
24.         listen {{ nginx_port | default(80) }};
25.         server_name _;
27.         location / {
28.             root /usr/share/nginx/html;
29.             index index.html;
30.         }
31.     }
32. }

复制代码

1. 定义默认变量（roles/nginx/defaults/main.yml）：

2. ---
3. nginx_port: 80

复制代码

1. 在Playbook中使用角色：

2. ---
3. - name: Configure web servers
4.   hosts: web_servers
5.   become: yes
6.   roles:
7.     - nginx

复制代码

集群管理实战

部署高可用Web集群

在这个实战案例中，我们将使用Ansible部署一个高可用的Web集群，包括负载均衡器和多个Web服务器。

2. web_cluster/
3. ├── group_vars/
4. │   ├── all.yml
5. │   ├── load_balancers.yml
6. │   └── web_servers.yml
7. ├── roles/
8. │   ├── common/
9. │   ├── haproxy/
10. │   └── nginx/
11. ├── inventory
12. └── site.yml

复制代码

2. [load_balancers]
3. lb1.example.com
4. lb2.example.com
6. [web_servers]
7. web1.example.com
8. web2.example.com
9. web3.example.com
11. [cluster:children]
12. load_balancers
13. web_servers

复制代码

group_vars/all.yml:

2. ---
3. ansible_ssh_user: ansible
4. ansible_ssh_private_key_file: ~/.ssh/id_rsa

复制代码

group_vars/load_balancers.yml:

2. ---
3. haproxy_port: 80
4. haproxy_stats_port: 8404

复制代码

group_vars/web_servers.yml:

2. ---
3. nginx_port: 8080

复制代码

roles/common/tasks/main.yml:

2. ---
3. - name: Update system packages
4.   package:
5.     name: "*"
6.     state: latest
7.   when: update_packages | default(false)
9. - name: Install common packages
10.   package:
11.     name: "{{ item }}"
12.     state: present
13.   loop:
14.     - vim
15.     - htop
16.     - net-tools
17.     - telnet

复制代码

roles/haproxy/tasks/main.yml:

2. ---
3. - name: Install HAProxy
4.   package:
5.     name: haproxy
6.     state: present
8. - name: Configure HAProxy
9.   template:
10.     src: haproxy.cfg.j2
11.     dest: /etc/haproxy/haproxy.cfg
12.   notify: Restart HAProxy
14. - name: Start HAProxy service
15.   service:
16.     name: haproxy
17.     state: started
18.     enabled: yes

复制代码

roles/haproxy/templates/haproxy.cfg.j2:

2. global
3.     log         127.0.0.1 local2
4.     chroot      /var/lib/haproxy
5.     pidfile     /var/run/haproxy.pid
6.     maxconn     4000
7.     user        haproxy
8.     group       haproxy
9.     daemon
11.     stats socket /var/lib/haproxy/stats
13. defaults
14.     mode                    http
15.     log                     global
16.     option                  httplog
17.     option                  dontlognull
18.     option http-server-close
19.     option forwardfor       except 127.0.0.0/8
20.     option                  redispatch
21.     retries                 3
22.     timeout http-request    10s
23.     timeout queue           1m
24.     timeout connect         10s
25.     timeout client          1m
26.     timeout server          1m
27.     timeout http-keep-alive 10s
28.     timeout check           10s
29.     maxconn                 3000
31. frontend main
32.     bind *:{{ haproxy_port }}
33.     acl url_static       path_beg       -i /static /images /javascript /stylesheets
34.     acl url_static       path_end       -i .jpg .gif .png .css .js
35.     use_backend static          if url_static
36.     default_backend             app
38. backend static
39.     balance     roundrobin
40.     server      static 127.0.0.1:4331 check
42. backend app
43.     balance     roundrobin
44. {% for host in groups['web_servers'] %}
45.     server  {{ hostvars[host]['inventory_hostname'] }} {{ hostvars[host]['ansible_host'] }}:{{ nginx_port }} check
46. {% endfor %}
48. listen stats
49.     bind *:{{ haproxy_stats_port }}
50.     stats enable
51.     stats uri /
52.     stats hide-version
53.     stats auth admin:password

复制代码

roles/haproxy/handlers/main.yml:

2. ---
3. - name: Restart HAProxy
4.   service:
5.     name: haproxy
6.     state: restarted

复制代码

roles/nginx/tasks/main.yml:

2. ---
3. - name: Install nginx
4.   package:
5.     name: nginx
6.     state: present
8. - name: Create nginx config
9.   template:
10.     src: nginx.conf.j2
11.     dest: /etc/nginx/nginx.conf
12.   notify: Restart nginx
14. - name: Create custom index.html
15.   template:
16.     src: index.html.j2
17.     dest: /usr/share/nginx/html/index.html
18.   notify: Restart nginx
20. - name: Start nginx service
21.   service:
22.     name: nginx
23.     state: started
24.     enabled: yes

复制代码

roles/nginx/templates/nginx.conf.j2:

2. user nginx;
3. worker_processes {{ ansible_processor_vcpus }};
4. error_log /var/log/nginx/error.log;
5. pid /run/nginx.pid;
7. events {
8.     worker_connections 1024;
9. }
11. http {
12.     include /etc/nginx/mime.types;
13.     default_type application/octet-stream;
15.     sendfile on;
16.     tcp_nopush on;
17.     tcp_nodelay on;
18.     keepalive_timeout 65;
19.     types_hash_max_size 2048;
21.     include /etc/nginx/conf.d/*.conf;
23.     server {
24.         listen {{ nginx_port }};
25.         server_name _;
27.         location / {
28.             root /usr/share/nginx/html;
29.             index index.html;
30.         }
31.     }
32. }

复制代码

roles/nginx/templates/index.html.j2:

2. <!DOCTYPE html>
3. <html>
4. <head>
5.     <title>Welcome to {{ inventory_hostname }}</title>
6.     <style>
7.         body {
8.             font-family: Arial, sans-serif;
9.             margin: 40px;
10.             background-color: #f0f0f0;
11.         }
12.         .container {
13.             background-color: white;
14.             padding: 20px;
15.             border-radius: 5px;
16.             box-shadow: 0 0 10px rgba(0,0,0,0.1);
17.         }
18.         h1 {
19.             color: #333;
20.         }
21.     </style>
22. </head>
23. <body>
24.     <div class="container">
25.         <h1>Welcome to {{ inventory_hostname }}</h1>
26.         <p>This server is part of a web cluster managed by Ansible.</p>
27.         <p>Server IP: {{ ansible_default_ipv4.address }}</p>
28.         <p>Hostname: {{ inventory_hostname }}</p>
29.     </div>
30. </body>
31. </html>

复制代码

roles/nginx/handlers/main.yml:

2. ---
3. - name: Restart nginx
4.   service:
5.     name: nginx
6.     state: restarted

复制代码

2. ---
3. - name: Configure load balancers
4.   hosts: load_balancers
5.   become: yes
6.   roles:
7.     - common
8.     - haproxy
10. - name: Configure web servers
11.   hosts: web_servers
12.   become: yes
13.   roles:
14.     - common
15.     - nginx

复制代码

运行这个Playbook：

2. ansible-playbook -i inventory site.yml

复制代码

数据库集群部署

在这个案例中，我们将部署一个MySQL主从复制集群。

2. mysql_cluster/
3. ├── group_vars/
4. │   ├── all.yml
5. │   ├── mysql_master.yml
6. │   └── mysql_slaves.yml
7. ├── roles/
8. │   ├── common/
9. │   └── mysql/
10. ├── inventory
11. └── site.yml

复制代码

2. [mysql_master]
3. db1.example.com
5. [mysql_slaves]
6. db2.example.com
7. db3.example.com
9. [mysql_cluster:children]
10. mysql_master
11. mysql_slaves

复制代码

group_vars/all.yml:

2. ---
3. ansible_ssh_user: ansible
4. ansible_ssh_private_key_file: ~/.ssh/id_rsa
5. mysql_root_password: "SecureRootPassword123!"
6. mysql_replication_user: "repl_user"
7. mysql_replication_password: "ReplPassword123!"

复制代码

group_vars/mysql_master.yml:

2. ---
3. mysql_server_id: 1

复制代码

group_vars/mysql_slaves.yml:

2. ---
3. mysql_server_id: "{{ 10000 + play_hosts.index(inventory_hostname) }}"

复制代码

roles/mysql/tasks/main.yml:

2. ---
3. - name: Install MySQL server
4.   package:
5.     name: "{{ mysql_package }}"
6.     state: present
8. - name: Start MySQL service
9.   service:
10.     name: "{{ mysql_service }}"
11.     state: started
12.     enabled: yes
14. - name: Set MySQL root password
15.   mysql_user:
16.     login_user: root
17.     login_password: ""
18.     user: root
19.     password: "{{ mysql_root_password }}"
20.     host_all: yes
21.   ignore_errors: yes
23. - name: Create .my.cnf file with root credentials
24.   template:
25.     src: my.cnf.j2
26.     dest: /root/.my.cnf
27.     owner: root
28.     group: root
29.     mode: 0600
31. - name: Remove anonymous users
32.   mysql_user:
33.     login_user: root
34.     login_password: "{{ mysql_root_password }}"
35.     user: ""
36.     host_all: yes
37.     state: absent
39. - name: Remove test database
40.   mysql_db:
41.     login_user: root
42.     login_password: "{{ mysql_root_password }}"
43.     name: test
44.     state: absent
46. - name: Configure MySQL server
47.   template:
48.     src: my.cnf.server.j2
49.     dest: /etc/my.cnf
50.   notify: Restart MySQL
52. - name: Create replication user
53.   mysql_user:
54.     login_user: root
55.     login_password: "{{ mysql_root_password }}"
56.     name: "{{ mysql_replication_user }}"
57.     password: "{{ mysql_replication_password }}"
58.     priv: "*.*:REPLICATION SLAVE"
59.     host: "%"
60.     state: present
61.   when: "'mysql_master' in group_names"
63. - name: Get master binlog position
64.   mysql_replication:
65.     login_user: root
66.     login_password: "{{ mysql_root_password }}"
67.     mode: getmaster
68.   register: master
69.   when: "'mysql_master' in group_names"
71. - name: Configure replication on slaves
72.   mysql_replication:
73.     login_user: root
74.     login_password: "{{ mysql_root_password }}"
75.     mode: changemaster
76.     master_host: "{{ hostvars[groups['mysql_master'][0]]['ansible_host'] }}"
77.     master_user: "{{ mysql_replication_user }}"
78.     master_password: "{{ mysql_replication_password }}"
79.     master_log_file: "{{ master.File }}"
80.     master_log_pos: "{{ master.Position }}"
81.   when: "'mysql_slaves' in group_names"
83. - name: Start replication on slaves
84.   mysql_replication:
85.     login_user: root
86.     login_password: "{{ mysql_root_password }}"
87.     mode: startslave
88.   when: "'mysql_slaves' in group_names"

复制代码

roles/mysql/vars/main.yml:

2. ---
3. mysql_package: "mariadb-server"
4. mysql_service: "mariadb"

复制代码

roles/mysql/templates/my.cnf.j2:

2. [client]
3. user=root
4. password={{ mysql_root_password }}

复制代码

roles/mysql/templates/my.cnf.server.j2:

2. [mysqld]
3. datadir=/var/lib/mysql
4. socket=/var/lib/mysql/mysql.sock
5. symbolic-links=0
6. server-id={{ mysql_server_id }}
7. {% if 'mysql_master' in group_names %}
8. log-bin=mysql-bin
9. binlog_format=ROW
10. {% endif %}
12. [mysqld_safe]
13. log-error=/var/log/mariadb/mariadb.log
14. pid-file=/var/run/mariadb/mariadb.pid
16. !includedir /etc/my.cnf.d

复制代码

2. ---
3. - name: Configure MySQL master
4.   hosts: mysql_master
5.   become: yes
6.   roles:
7.     - common
8.     - mysql
10. - name: Configure MySQL slaves
11.   hosts: mysql_slaves
12.   become: yes
13.   roles:
14.     - common
15.     - mysql

复制代码

运行这个Playbook：

2. ansible-playbook -i inventory site.yml

复制代码

高级应用

动态清单

动态清单允许您从外部源（如云服务API、CMDB等）动态获取主机信息。以下是一个使用AWS EC2作为动态清单的示例：

2. pip install boto3

复制代码

2. mkdir -p ~/.aws
3. cat > ~/.aws/credentials << EOF
4. [default]
5. aws_access_key_id = YOUR_ACCESS_KEY
6. aws_secret_access_key = YOUR_SECRET_KEY
7. EOF

复制代码

2. #!/usr/bin/env python3
4. import boto3
5. import json
7. def get_ec2_instances():
8.     ec2 = boto3.client('ec2')
9.     response = ec2.describe_instances()
10.    
11.     inventory = {
12.         '_meta': {
13.             'hostvars': {}
14.         }
15.     }
16.    
17.     for reservation in response['Reservations']:
18.         for instance in reservation['Instances']:
19.             if instance['State']['Name'] != 'running':
20.                 continue
21.                
22.             instance_id = instance['InstanceId']
23.             private_ip = instance.get('PrivateIpAddress', '')
24.             public_ip = instance.get('PublicIpAddress', '')
25.             
26.             # Get tags
27.             tags = {}
28.             for tag in instance.get('Tags', []):
29.                 tags[tag['Key']] = tag['Value']
30.             
31.             # Add to inventory
32.             inventory['_meta']['hostvars'][instance_id] = {
33.                 'ansible_host': public_ip if public_ip else private_ip,
34.                 'private_ip': private_ip,
35.                 'public_ip': public_ip,
36.                 'instance_type': instance['InstanceType'],
37.                 'tags': tags
38.             }
39.             
40.             # Add to groups based on tags
41.             if 'Name' in tags:
42.                 group_name = tags['Name']
43.                 if group_name not in inventory:
44.                     inventory[group_name] = []
45.                 inventory[group_name].append(instance_id)
46.             
47.             if 'Environment' in tags:
48.                 group_name = tags['Environment']
49.                 if group_name not in inventory:
50.                     inventory[group_name] = []
51.                 inventory[group_name].append(instance_id)
52.    
53.     return inventory
55. if __name__ == '__main__':
56.     print(json.dumps(get_ec2_instances(), indent=2))

复制代码

2. # 使脚本可执行
3. chmod +x aws_ec2.py
5. # 测试清单
6. ./aws_ec2.py
8. # 使用动态清单运行Ansible命令
9. ansible -i ./aws_ec2.py all -m ping
11. # 使用动态清单运行Playbook
12. ansible-playbook -i ./aws_ec2.py site.yml

复制代码

使用Ansible Vault加密敏感数据

Ansible Vault允许您加密敏感数据，如密码、API密钥等。

2. ansible-vault create secret.yml

复制代码

2. ansible-vault edit secret.yml

复制代码

2. ---
3. - name: Example with vault
4.   hosts: all
5.   become: yes
6.   vars_files:
7.     - secret.yml
8.   
9.   tasks:
10.     - name: Create database user
11.       mysql_user:
12.         login_user: root
13.         login_password: "{{ mysql_root_password }}"
14.         name: "{{ db_user }}"
15.         password: "{{ db_password }}"
16.         priv: "{{ db_name }}.*:ALL"
17.         state: present

复制代码

2. ansible-playbook --ask-vault-pass site.yml

复制代码

或者使用密码文件：

2. echo "MyVaultPassword" > vault_pass.txt
3. ansible-playbook --vault-password-file vault_pass.txt site.yml

复制代码

使用Ansible Tower/AWX

Ansible Tower（或其开源版本AWX）是一个Web界面和REST API，用于Ansible的集中管理、控制和监控。

2. # 安装Docker
3. yum install -y docker
5. # 启动Docker服务
6. systemctl start docker
7. systemctl enable docker
9. # 克隆AWX仓库
10. git clone https://github.com/ansible/awx.git
11. cd awx/installer
13. # 编辑inventory文件，配置密码等参数
14. vim inventory
16. # 运行安装 playbook
17. ansible-playbook -i inventory install.yml

复制代码

1. 通过Web界面访问AWX（默认端口80）。
2. 创建组织和项目。
3. 添加清单（可以是静态或动态的）。
4. 创建凭证，用于连接到受管节点。
5. 创建模板，定义要运行的Playbook。
6. 启动作业，查看执行结果。

自定义模块开发

当Ansible的现有模块无法满足您的需求时，您可以开发自定义模块。

以下是一个简单的自定义模块，用于检查文件是否存在：

2. #!/usr/bin/python
4. from ansible.module_utils.basic import AnsibleModule
6. def main():
7.     module = AnsibleModule(
8.         argument_spec=dict(
9.             path=dict(type='str', required=True),
10.         ),
11.         supports_check_mode=True
12.     )
13.    
14.     path = module.params['path']
15.    
16.     try:
17.         with open(path, 'r') as f:
18.             content = f.read()
19.         module.exit_json(changed=False, exists=True, content=content)
20.     except IOError as e:
21.         module.exit_json(changed=False, exists=False, msg=str(e))
23. if __name__ == '__main__':
24.     main()

复制代码

1. 将模块放在library目录下：

2. project/
3. ├── library/
4. │   └── file_exists.py
5. └── site.yml

复制代码

1. 在Playbook中使用自定义模块：

2. ---
3. - name: Use custom module
4.   hosts: all
5.   tasks:
6.     - name: Check if file exists
7.       file_exists:
8.         path: /etc/hosts
9.       register: result
10.    
11.     - name: Print result
12.       debug:
13.         msg: "File exists: {{ result.exists }}"

复制代码

性能优化和故障排除

性能优化

对于长时间运行的任务，可以使用异步执行：

2. ---
3. - name: Run long task asynchronously
4.   hosts: all
5.   tasks:
6.     - name: Run system update
7.       yum:
8.         name: "*"
9.         state: latest
10.       async: 3600
11.       poll: 0
12.       register: yum_result
13.    
14.     - name: Wait for update to complete
15.       async_status:
16.         jid: "{{ yum_result.ansible_job_id }}"
17.       register: job_result
18.       until: job_result.finished
19.       retries: 300
20.       delay: 10

复制代码

Ansible提供了不同的策略插件来控制Playbook的执行方式：

2. ---
3. - name: Use free strategy
4.   hosts: all
5.   strategy: free
6.   tasks:
7.     - name: Task that can run independently
8.       command: echo "This task runs independently on all hosts"

复制代码

在ansible.cfg中启用pipelining可以提高SSH连接的效率：

2. [ssh_connection]
3. pipelining = True

复制代码

缓存Facts可以减少Playbook的执行时间：

2. [defaults]
3. gathering = smart
4. fact_caching = jsonfile
5. fact_caching_connection = /tmp/ansible_facts_cache
6. fact_caching_timeout = 86400

复制代码

故障排除

使用-v（verbose）标志来获取更详细的输出：

2. ansible-playbook -v site.yml

复制代码

使用-vvv或-vvvv获取更详细的调试信息：

2. ansible-playbook -vvvv site.yml

复制代码

使用--check标志来模拟Playbook的执行，而不实际更改系统：

2. ansible-playbook --check site.yml

复制代码

使用--diff标志来显示文件更改的差异：

2. ansible-playbook --diff site.yml

复制代码

使用--step标志来逐步执行Playbook，在每个任务前确认：

2. ansible-playbook --step site.yml

复制代码

1. SSH连接问题：

2. # 测试SSH连接
3. ansible all -m ping
5. # 检查SSH配置
6. ansible all -m debug -a "var=ansible_ssh_host"

复制代码

1. 权限问题：

2. ---
3. - name: Example with become
4.   hosts: all
5.   become: yes
6.   become_user: root
7.   tasks:
8.     - name: Task that requires root privileges
9.       command: echo "This task runs as root"

复制代码

1. 模块路径问题：

2. # 检查模块路径
3. ansible-doc -l | grep module_name
5. # 指定模块路径
6. ansible-playbook --module-path /path/to/modules site.yml

复制代码

1. 变量问题：

2. ---
3. - name: Debug variables
4.   hosts: all
5.   tasks:
6.     - name: Print all variables
7.       debug:
8.         var: hostvars[inventory_hostname]

复制代码

总结和展望

通过本文的学习，您已经从Ansible的基础概念开始，逐步掌握了Ansible集群管理脚本编写的各个方面。从简单的Ad-hoc命令到复杂的Playbook编写，从变量和模板的使用到角色和动态清单的应用，再到自定义模块开发和性能优化，您现在具备了使用Ansible管理大规模服务器集群的能力。

Ansible作为一款强大的自动化工具，正在不断发展和完善。未来，我们可以期待Ansible在以下方面的进一步发展：

1. 更多的云服务集成：随着云计算的普及，Ansible将继续增强与各种云服务的集成能力。
2. 更强大的API和UI：Ansible Tower/AWX将提供更丰富的API和用户界面，使自动化管理更加便捷。
3. 更好的性能和可扩展性：Ansible将继续优化性能，提高在大规模环境中的执行效率。
4. 更丰富的模块生态系统：Ansible社区将继续贡献更多的模块，覆盖更广泛的应用场景。
5. 更智能的自动化：结合AI和机器学习技术，Ansible可能会提供更智能的自动化决策能力。

更多的云服务集成：随着云计算的普及，Ansible将继续增强与各种云服务的集成能力。

更强大的API和UI：Ansible Tower/AWX将提供更丰富的API和用户界面，使自动化管理更加便捷。

更好的性能和可扩展性：Ansible将继续优化性能，提高在大规模环境中的执行效率。

更丰富的模块生态系统：Ansible社区将继续贡献更多的模块，覆盖更广泛的应用场景。

更智能的自动化：结合AI和机器学习技术，Ansible可能会提供更智能的自动化决策能力。

作为运维工程师，持续学习和实践是掌握Ansible的关键。希望本文能够成为您Ansible学习之旅的有力指南，帮助您在自动化运维的道路上不断前进，轻松应对大规模服务器集群管理的挑战。

mai2

感謝分享