Why do operations engineers at large companies always seem so relaxed? They don’t have to manually deploy applications or manage servers every day, and they can even enjoy coffee leisurely in a café while the system continues to run stably. The secret lies in automated operations. Today, we will discuss how to use Python and Ansible to achieve automated deployment, allowing you to become that “relaxed” operations engineer!
You are responsible for managing dozens or even hundreds of servers, and every time you update the application, you have to log in to each server manually and execute the same commands.This is not only time-consuming but also prone to errors. Automated operations were created to solve this problem. With automation tools, you can deploy, configure, and manage all servers at once, greatly improving efficiency.
Python, as a simple and easy-to-learn programming language, is very suitable for writing automation scripts. Ansible is a powerful automation tool that uses YAML format configuration files, which are simple and easy to understand, making it ideal for beginners.
Before we start, we need to understand some basic concepts of Ansible:
Inventory: This is a file that lists all the servers you want to manage.
Playbook: This is the core configuration file of Ansible that defines the tasks you want to execute on the servers.
Module: Ansible provides many modules, each responsible for executing specific tasks, such as installing software, copying files, etc.
Let’s start with a simple example. Suppose you need to install Nginx on multiple servers and start it. You can write a Playbook to accomplish this task.
- hosts: webservers
become: yes
tasks:
- name: Install Nginx
apt:
name: nginx
state: present
- name: Start Nginx service
service:
name: nginx
state: started
In this Playbook:
hosts: webservers means this Playbook will execute on the servers in the webservers group.
become: yes means to execute the tasks with administrator privileges.
The tasks section defines two tasks: installing Nginx and starting the Nginx service.
In addition to installing software, Ansible can also be used to manage configuration files. Suppose you need to push the local Nginx configuration file to all servers and restart the Nginx service.
- hosts: webservers
become: yes
tasks:
- name: Copy Nginx configuration file
copy:
src: /path/to/local/nginx.conf
dest: /etc/nginx/nginx.conf
owner: root
group: root
mode: '0644'
- name: Restart Nginx service
service:
name: nginx
state: restarted
In this Playbook:
The copy module is used to copy the local nginx.conf file to the server’s /etc/nginx/ directory.
The service module is used to restart the Nginx service.
Sometimes, you may need to execute the same command on multiple servers. For example, you want to check the disk usage on all servers.
- hosts: all
become: yes
tasks:
- name: Check disk usage
shell: df -h
register: disk_usage
- name: Display disk usage
debug:
var: disk_usage.stdout_lines
In this Playbook:
The shell module is used to execute the df -h command to check disk usage.
register saves the output of the command to the disk_usage variable.
The debug module is used to display the output of the command.
YAML format: Ansible’s Playbook uses YAML format, and indentation is very important; it must be consistent.
Module documentation: Ansible provides rich module documentation, which can be consulted when problems arise.
Dry Run: Before officially executing the Playbook, you can use the –check parameter for a “dry run” to see what tasks the Playbook will execute without actually executing them.
Permission issues: Many tasks require administrator privileges, so remember to use become: yes in the Playbook.
Network issues: Ansible connects to servers via SSH, so ensure the network is smooth and the SSH configuration is correct.
Version compatibility: Different versions of Ansible may have some differences; it is recommended to use a newer stable version.
Through today’s learning, you have mastered how to use Ansible for automated deployment. We have walked you through the world of automated operations step by step, from installing Nginx, managing configuration files, to batch operations on servers. Automated operations not only improve work efficiency but also reduce human errors, making it an essential skill for modern operations engineers.
Now, you can try writing your own Ansible Playbook to deploy your applications on multiple servers. Remember, practice is the best way to learn, so get started!
[The above content is compiled from online resources. If there is any infringement, please contact for deletion.]