Ansible Use Cases: Practical Applications and Implementation with Examples

Ansible, a powerful open-source automation tool, is widely used for configuration management, application deployment, and orchestration. It allows DevOps teams to simplify and automate complex tasks with minimal effort, providing an efficient way to manage IT infrastructure. This article will walk through some common Ansible use cases, explain their significance, and provide detailed examples with implementation.

What is Ansible?

Ansible uses a simple YAML syntax known as playbooks to define configurations, deployments, and orchestrations. Its agentless nature (no need to install software on target machines) makes it lightweight and efficient, operating over SSH for Unix/Linux and WinRM for Windows systems. Ansible’s declarative approach makes it easy to describe desired states, automating tasks across multiple nodes.

Key Use Cases of Ansible

1. Configuration Management
2. Application Deployment
3. Continuous Delivery and CI/CD Pipeline Management
4. Provisioning Cloud Resources
5. Infrastructure as Code (IaC)
6. Orchestration of IT Workflows

1. Configuration Management

Ansible is commonly used to standardize and enforce configurations across multiple servers. Configuration management ensures that each system has the necessary software, files, permissions, and configurations for consistent operation. For example, managing user accounts, installing packages, and enforcing firewall rules across servers can be automated with Ansible.

Example: Enforcing Consistent Package Installation

Suppose we want to ensure that nginx is installed and running on several web servers. Here’s how it can be done using Ansible.

Playbook for Configuration Management

---
- name: Ensure nginx is installed and running
  hosts: webservers
  become: yes

  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present
      when: ansible_os_family == "Debian"

    - name: Ensure nginx is running
      service:
        name: nginx
        state: started
        enabled: yes

Explanation:

• This playbook targets the webservers group.
• It uses the apt module to install nginx on Debian-based systems.
• It ensures nginx is started and enabled on system boot.

2. Application Deployment

Deploying applications to multiple servers is often challenging. Ansible can simplify application deployment by automating the process, reducing errors, and providing a repeatable deployment environment.

Example: Deploying a Web Application

Consider deploying a simple web application that includes copying source code, installing dependencies, and setting up the environment.

Playbook for Application Deployment

---
- name: Deploy Flask web application
  hosts: webservers
  become: yes

  tasks:
    - name: Copy application code to server
      copy:
        src: /local/path/to/app/
        dest: /var/www/myapp/

    - name: Install Python dependencies
      pip:
        requirements: /var/www/myapp/requirements.txt
        virtualenv: /var/www/myapp/venv

    - name: Start Gunicorn server
      systemd:
        name: myapp
        state: started
        enabled: yes
        exec_start: /var/www/myapp/venv/bin/gunicorn -b 0.0.0.0:8000 myapp:app

Explanation:

• The playbook copies the application code to the target server.
• It installs Python dependencies using pip.
• Finally, it starts the application using Gunicorn, ensuring it launches on system boot.

3. Continuous Delivery and CI/CD Pipeline Management

Ansible is used in CI/CD pipelines to automate testing, build, and deployment phases. This is often integrated with Jenkins or GitLab CI to provide a fully automated pipeline.

Example: Configuring Ansible with Jenkins for CI/CD

Playbook for Deploying Application with Jenkins

---
- name: Deploy application via CI/CD pipeline
  hosts: webservers
  become: yes

  tasks:
    - name: Pull latest code from Git repository
      git:
        repo: 'https://github.com/your-repo/app.git'
        dest: /var/www/myapp
        version: master

    - name: Restart the application
      systemd:
        name: myapp
        state: restarted

Explanation:

• This playbook pulls the latest code from a Git repository.
• After updating the code, it restarts the application service to apply changes.

4. Provisioning Cloud Resources

Ansible’s modules for cloud services like AWS, Azure, and GCP allow DevOps teams to provision and manage resources. Tasks such as creating EC2 instances, configuring VPCs, and setting security groups can be automated.

Example: Provisioning an EC2 Instance in AWS

To provision an EC2 instance on AWS, Ansible requires boto3, the AWS SDK for Python, and a properly configured AWS CLI.

Playbook for EC2 Provisioning

---
- name: Provision EC2 instance on AWS
  hosts: localhost
  gather_facts: False
  vars:
    instance_type: t2.micro
    image_id: ami-0abcdef1234567890
    region: us-east-1

  tasks:
    - name: Launch EC2 instance
      amazon.aws.ec2:
        key_name: my_key
        instance_type: "{{ instance_type }}"
        image_id: "{{ image_id }}"
        region: "{{ region }}"
        wait: yes
      register: ec2

    - name: Output instance information
      debug:
        var: ec2.instances

Explanation:

• The playbook provisions an EC2 instance with the specified image and instance type.
• It waits until the instance is ready and then outputs the instance information.

5. Infrastructure as Code (IaC)

Ansible enables Infrastructure as Code (IaC) by allowing teams to define infrastructure configurations in code format. This ensures that infrastructure changes are version-controlled, transparent, and replicable.

Example: Setting Up a LAMP Stack

Playbook for LAMP Stack Setup

---
- name: Install and configure LAMP stack
  hosts: webservers
  become: yes

  tasks:
    - name: Install Apache, MySQL, and PHP
      apt:
        name: "{{ item }}"
        state: present
      loop:
        - apache2
        - mysql-server
        - php
        - libapache2-mod-php

    - name: Start Apache and MySQL
      service:
        name: "{{ item }}"
        state: started
        enabled: yes
      loop:
        - apache2
        - mysql

Explanation:

• This playbook installs Apache, MySQL, and PHP (the LAMP stack) on target servers.
• It then starts and enables the Apache and MySQL services.

6. Orchestration of IT Workflows

Ansible can orchestrate complex workflows by coordinating multiple systems and services. For example, orchestrating a rolling update across multiple servers or implementing blue-green deployments.

Example: Rolling Update for Web Servers

Playbook for Rolling Update

---
- name: Perform rolling update on web servers
  hosts: webservers
  become: yes
  serial: 2

  tasks:
    - name: Pull latest application code
      git:
        repo: 'https://github.com/your-repo/app.git'
        dest: /var/www/myapp

    - name: Restart application service
      systemd:
        name: myapp
        state: restarted

Explanation:

• The serial keyword specifies that the update is performed on two servers at a time.
• This ensures minimal downtime, as only a subset of servers is updated simultaneously.

Conclusion

Ansible’s versatility enables automation across diverse areas, from configuration management and application deployment to cloud provisioning and IT workflow orchestration. The playbooks illustrated here provide a starting point for implementing robust automation solutions. As infrastructure needs scale, Ansible can be scaled and extended to support a wide variety of advanced use cases, making it an essential tool in modern DevOps practices.