DevOps - Ansible

Quiz

Ansible is a powerful tool that helps us automate tasks. It makes configuration management and application deployment easier. So, it is a key resource for DevOps.

In this chapter, we will look at Ansible's structure. We will talk about key ideas like inventories and playbooks. We will also learn how to set it up for good DevOps use. We will discuss how to write good playbooks and how to use Ansible for continuous integration and deployment.

Understanding Ansible Architecture

We know that Ansible is a free tool for automation. It uses a client-server setup and mainly works without a master. Its setup has some important parts:

Control Node − This is the machine where we install Ansible. We start tasks from here. It runs playbooks and talks to the managed nodes.
Managed Nodes − These are the machines where Ansible does its work. They can be real servers, virtual machines, or cloud instances. We do not need to install any agents on these nodes. Ansible uses SSH to communicate.
Inventory − An inventory file shows all the managed nodes. It can be static like INI or YAML format. It can also be dynamic if we pull it from cloud providers or other places.
Modules − Ansible has many modules that do specific tasks. They can install packages, copy files, or manage services. We can also create our own modules.
Playbooks − These are YAML files. They tell us what we want the managed nodes to be like. They list the tasks to do and the order to do them.
Plugins − Ansible can be extended with plugins. These can change how it works or add new features. For example, we have connection, action, or filter plugins.

By using this setup, Ansible is simple and can grow easily. This makes it a great choice for DevOps practices.

Ansible Inventories

We use inventories in Ansible to show the hosts and groups of hosts where we will run tasks. An inventory can be static, like a simple text file, or dynamic, which is made by a script.

Static Inventory Example

A static inventory is usually in a file, like hosts.ini −

[webservers]
web1.example.com
web2.example.com

[databases]
db1.example.com

Dynamic Inventory

We can get dynamic inventories from cloud providers or other sources. For example, when we use AWS −

ansible-cmd -i aws_ec2.py all -m ping

Ansible Playbooks

We use Ansible playbooks as YAML files. They help us define a set of tasks that we want to run on our hosts. Playbooks are very important for automating tasks. They help us do things in a repeatable and organized way. Each playbook has one or more plays. These plays connect our hosts to the tasks we want to perform.

Structure of a Playbook

---
- name: Playbook Example
  hosts: webservers
  tasks:
    - name: Install Apache
      yum:
        name: httpd
        state: present

    - name: Start Apache
      service:
        name: httpd
        state: started

Key Components

Hosts − These are the target machines we define in inventory.
Tasks − These are the actions we need to do. We use modules for this.
Modules − These are built-in or custom scripts. For example, yum and service are modules we use to run tasks.

Playbooks are very important for managing complex workflows. They help us keep configurations consistent across different environments.

Ansible Roles

Roles help us organize Ansible code better. A role can have tasks, handlers, variables, and templates. This makes it easy to use the same role in different playbooks.

Role Directory Structure

my_role/
   tasks/
      main.yml
   handlers/
      main.yml
   vars/
      main.yml
   templates/
       config.j2

These ideas inventories, playbooks, and roles make the main parts of Ansible's configuration management and automation.

Setting Up Ansible for DevOps

We can set up Ansible for DevOps by following some simple steps. This will help us with configuration management and deployment.

Here are the prerequisites −

Ansible works best on Linux. We need to make sure we have a compatible OS.
Ansible needs Python to run. We can install it using our package manager like apt or yum.

Installation Using Package Managers (like for Ubuntu) −

sudo apt update
sudo apt install ansible

Installation Using pip (Python package manager) −

pip install ansible

Verify Installation using the following command −

ansible --version

Configuration

Inventory file − We need to define our hosts in /etc/ansible/hosts or in a custom file −

[webservers]
web1.example.com
web2.example.com

Ansible.cfg: We can change some settings in ansible.cfg −

[defaults]
inventory = ./inventory
remote_user = your_user

SSH Access

We have to make sure we can access our managed nodes without a password −

ssh-keygen -t rsa
ssh-copy-id user@node

This setup helps us use Ansible to automate tasks on many servers easily.

Writing Effective Playbooks

We know that Ansible playbooks are YAML files. They define the automation tasks we want to run on managed nodes. When we write effective playbooks, we make them easier to read, reuse, and maintain.

Here are some important tips:

Pick clear descriptive names for your playbooks. This helps us understand what each playbook does.
Organize the playbooks well. We can use roles to group tasks. This makes everything neat.
Define variables in a separate vars If you have sensitive info, then use Ansible Vault. Here is an example −

vars:
app_version: "1.0.0"

Make sure the playbooks can run many times. They should not change the system state if it is not needed. Use Ansible modules that are idempotent.

Use handlers to manage services. They only notify when a change happens. Here is an example −

handlers:
  - name: restart web server
    service:
      name: httpd
      state: restarted

Add comments to explain complex tasks or logic. For example −

# Install the latest version of nginx
- name: Install nginx
  yum:
    name: nginx
    state: latest

By following these tips, we can make efficient and easy-to-manage Ansible playbooks. This will help us in our DevOps work.

Using Ansible for Continuous Integration and Deployment

We can use Ansible to make Continuous Integration (CI) and Continuous Deployment (CD) easier. Ansible helps us set up and manage environments, deploy applications, and run tests automatically. Here is how we can put Ansible into our CI/CD pipelines.

Using Ansible, we can run playbooks many times without changing the result after the first run. This makes our deployments more predictable.

Ansible does not need agents on target machines. This helps us keep things simple.

Workflow Example

Environment Setup − We can use Ansible to set up and configure environments automatically −

- hosts: all
  tasks:
    - name: Install Docker
      apt:
        name: docker.io
        state: present

Code Deployment − We can deploy our application code using playbooks −

- hosts: webservers
  tasks:
    - name: Deploy application
      copy:
        src: /local/path/to/app
        dest: /var/www/app

Testing − We can run tests automatically after we deploy −

- hosts: testservers
  tasks:
    - name: Run tests
      command: /path/to/test_script.sh

Integration with CI/CD Tools

Jenkins − We can use the Ansible plugin to run playbooks as build steps.
GitLab CI − We can call Ansible from .gitlab-ci.yml to automate our deployment.

By using Ansible in our CI/CD, we can deliver software faster and more reliably. It also helps us to reduce the need for manual work.

Conclusion

In this chapter, we looked at the basics of Ansible. We talked about its structure and important ideas like inventories, playbooks, and roles. We also showed how to set it up for DevOps environments.

It is important to write good playbooks and manage configurations well. Ansible helps us with continuous integration and deployment. With Ansible, we can make automation better. We can also make workflows easier and improve how we work in software development.

Print Page