Day 58 of #90DaysOfDevOps
What are the Ansible playbooks?
Playbooks are used to run multiple tasks, assign roles, and define configurations, deployment steps, and variables.
If you’re using multiple servers, Ansible playbooks organize the steps between the assembled machines or servers and get them organized and running in the way the users need them to.
Consider playbooks as the equivalent of instruction manuals.
Ansible playbooks are written in YAML.
Task-01
Write an Ansible playbook to create a file on a different server
Write an ansible playbook to create a new user.
Write an Ansible playbook to install docker on a group of servers
Task-02
- Write a blog about writing Ansible playbooks with the best practices.
Ansible playbook to create a file on a different server:
---
- name: This playbook will creates a file
hosts: all
become: true
tasks:
- name: create a file
file:
path: /home/ubuntu/demo.txt
state: touch
"---" defines the
list
in yaml file."name" defines the name of the yaml file.
"hosts" define which hosts to perform the task.
"become" defines whether the task is to be performed as a root user or not.
"tasks" defines all the tasks that are going to be performed.
"tasks - name" defines the specific name of the task.
"file" is used to indicate that the task is on file as we are going to create a file. It works as a module.
"path" = specify the path where the action is going to be performed.
"state" = which command is going to use.
Run command: ansible-playbook create-file.yaml -i /home/ubuntu/servers_list.yaml --private-key=~/.ssh/ansible-master.pem
Check on other servers:
Write an ansible playbook to create a new user:
---
- name: This file will creates a user on different servers
hosts: all
become: true
tasks:
- name: create a user
user: name=neel-soni
Here, user
will create a user with the name neel-soni
Run the command: ansible-playbook create_user.yaml -i /home/ubuntu/servers_list.yaml --private-key=~/.ssh/ansible-master.pem
To check run the command on other servers: cat /etc/passwd
Write an Ansible playbook to install docker on a group of servers:
---
- name: This playbook will install docker on all the servers.
hosts: all
become: true
tasks:
- name: Add docker GPG apt key
apt_key:
url: https://download.docker.com/linux/ubuntu/gpg
state: present
- name: Add docker repository
apt_repository:
repo: deb https://download.docker.com/linux/ubuntu focal stable
state: present
- name: Update all apt packages
apt: update_cache=yes force_apt_get=yes cache_valid_time=3600
- name: Upgrade all apt packages
apt: state=latest force_apt_get=yes
- name: install docker
apt:
name: docker-ce
state: latest
In the fisrt task, it will download the key.
In second, it will add the repository.
Third and forth, it will update and upgrade the packages.
In last, it will install docker.
Run the command: ansible-playbook install_docker.yaml -i /home/ubuntu/servers_list.yaml --private-key=~/.ssh/ansible-master.pem
Check on other servers:
To write an Ansible playbook there are multiple things to consider.
Ansible is a powerful open-source automation tool that allows you to automate IT infrastructure management. Ansible playbooks are the configuration files that describe the desired state of your systems. Writing Ansible playbooks with best practices can make your automation more robust, reliable, and scalable. In this blog, we will discuss some best practices for writing Ansible playbooks.
Use a clear structure:
Make sure your playbook is organized and easy to read. Use comments and section headers to explain what each part of the playbook does. Avoid nesting too many tasks or plays inside each other, as it can make the playbook difficult to read and maintain.
Use idempotent tasks:
Idempotency is one of the key principles of Ansible. It means that a task should be designed in such a way that it can be executed repeatedly without changing the state of the system. This makes your playbook more robust and prevents unexpected changes to the system. You can achieve idempotency by using modules that are designed to be idempotent, such as apt, yum, and copy.
Example:
- name: Install Apache web server
apt:
name: apache2
state: latest
In this example, the apt module will only install the Apache web server if it is not already installed or if there is a newer version available.
Use variables:
Variables can make your playbook more flexible and reusable. They allow you to store values that can be used across multiple tasks and playbooks. You can define variables in the playbook itself or in separate files, such as group_vars or host_vars.
Example:
- name: Install Nginx web server
apt:
name: nginx
state: latest
- name: Configure Nginx web server
template:
src: nginx.conf.j2
dest: /etc/nginx/nginx.conf
vars:
nginx_port: 80
In this example, we are using a variable nginx_port to define the port number used by Nginx. The variable is defined in the vars section of the template task.
Use roles:
Roles are a way to organize your tasks, variables, and files into reusable components. They can be used across multiple playbooks and provide a way to share functionality between different teams. Roles can also make your playbook more modular and easier to maintain.
Example:
- name: Install web serve
hosts: all
roles:
- webserver
In this example, we are using a role called webserver to install the web server on the all group of hosts.
Use tags:
Tags allow you to selectively run specific tasks or groups of tasks within a playbook. This can be useful when testing or debugging your playbook or when you need to run a subset of tasks. Tags can be added to individual tasks or to entire plays.
Example:
- name: Install web serve
hosts: all
become: yes
tags:
- webserver
tasks:
- name: Install Apache web server
apt:
name: apache2
state: latest
tags:
- apache
- name: Install Nginx web server
apt:
name: nginx
state: latest
tags:
- nginx
In this example, we are using tags to selectively run the Apache or Nginx installation tasks.
Use conditionals:
Conditionals allow you to execute a task only if a specific condition is met. This can be useful when you need to run a task only on a subset of hosts or when you need to run a task only if a specific variable is defined.
Example:
---
- name: Example playbook with a conditional
hosts: all
vars:
myvar: "foo"
tasks:
- name: Task 1
debug:
msg: "This task will always run"
- name: Task 2
debug:
msg: "This task will run if myvar equals 'foo'"
when: myvar == "foo"
In this example, the playbook has two tasks. Task 1 will always run because it doesn't have a conditional attached to it. Task 2 will only run if the variable myvar is equal to "foo". If myvar has any other value, Task 2 will be skipped.
By following these best practices, you can write efficient, modular, and maintainable Ansible playbooks that can be easily adapted to different environments and situations.
---