Automating IT Tasks with Ansible Playbooks

Ansible is a versatile automation tool that simplifies the complexities of IT management, making it easier to deploy applications, configure services, and orchestrate tasks across multiple servers. In this blog, we will explore key examples from Ansible playbooks that demonstrate how to leverage this powerful tool effectively.

1. Basic Server Setup

The initial step in any automated deployment is setting up the servers with the necessary packages and configurations. Here's an example of a basic server setup playbook:

- name: Basic Server Setup
  hosts: servers
  become: yes
  tasks:
    - name: Update apt cache
      apt:
        update_cache: yes

    - name: Install necessary packages
      apt:
        name: "{{ item }}"
        state: present
      with_items:
        - vim
        - git
        - curl

    - name: Configure timezone
      timezone:
        name: America/New_York

    - name: Ensure NTP service is running
      service:
        name: ntp
        state: started
        enabled: yes

This playbook covers essential tasks such as updating package repositories, installing vital packages, and configuring the system’s timezone and NTP service.

2. Deploying a Web Application

Another common use case for Ansible is deploying web applications. This playbook illustrates how to copy an HTML file to web servers and ensure that Apache is running:

- name: Deploy Web Application
  hosts: webservers
  become: yes
  tasks:
    - name: Copy index.html to web servers
      copy:
        src: /local/path/to/index.html
        dest: /var/www/html/index.html
        owner: www-data
        group: www-data
        mode: '0644'

    - name: Ensure Apache service is running
      service:
        name: apache2
        state: started
        enabled: yes

This simple yet effective playbook automatically deploys web content and ensures that the web server is operational.

3. Database Server Configuration

For organizations utilizing databases, configuring a PostgreSQL database server is crucial. Here’s a playbook that accomplishes this:

- name: Configure PostgreSQL Database Server
  hosts: db_servers
  become: yes
  tasks:
    - name: Install PostgreSQL database server
      apt:
        name: postgresql
        state: present

    - name: Configure PostgreSQL authentication
      template:
        src: pg_hba.conf.j2
        dest: /etc/postgresql/12/main/pg_hba.conf
        owner: postgres
        group: postgres
        mode: '0640'
      notify: 
        - Restart PostgreSQL

  handlers:
    - name: Restart PostgreSQL
      service:
        name: postgresql
        state: restarted

This example highlights how to install PostgreSQL and establish user authentication with a custom configuration file.

4. Continuous Integration Setup

In the modern development landscape, continuous integration (CI) is essential. Below is a playbook for setting up a Jenkins server:

- name: Setup Jenkins CI Server
  hosts: jenkins_server
  become: yes
  tasks:
    - name: Install Java
      apt:
        name: openjdk-11-jdk
        state: present

    - name: Add Jenkins repository key
      apt_key:
        url: https://pkg.jenkins.io/debian-stable/jenkins.io.key
        state: present

    - name: Add Jenkins repository
      apt_repository:
        repo: deb https://pkg.jenkins.io/debian-stable binary/
        state: present

    - name: Install Jenkins
      apt:
        name: jenkins
        state: present

This playbook sets up Jenkins with all necessary components, ensuring that your CI pipeline is ready to go.

5. Application Deployment with Docker

With the growing adoption of containerized applications, deploying Dockerized applications with Ansible is straightforward:

- name: Deploy Dockerized Application
  hosts: docker_servers
  become: yes
  tasks:
    - name: Pull Docker image
      docker_image:
        name: myapp_image
        source: pull

    - name: Run Docker container
      docker_container:
        name: myapp_container
        image: myapp_image
        state: started
        ports:
          - "8080:80"

This playbook illustrates the simplicity of managing Docker containers using Ansible, allowing for effortless deployment of applications.

Conclusion

Ansible playbooks are powerful tools that automate a wide range of IT tasks, streamlining processes and reducing the possibility of human error. By leveraging these examples, IT professionals can efficiently manage server configurations, deployments, and integrations, making Ansible an essential asset in the modern DevOps toolkit.

Feel free to dive deeper into Ansible's documentation or explore additional playbook examples to expand your automation capabilities!