Ansible Module Overview: Core Modules and Use Cases

In the previous article, we discussed inventories in Ansible and how to manage infrastructure using groups and host variables. This laid the groundwork for using modules and roles in Ansible. Next, we’ll dive deeper into Ansible modules and roles—exploring how they work, how to use them, and how to customize them.

What Is an Ansible Module?

An Ansible module is a self-contained program that performs a specific task—such as file management, package installation, or service control. Modules in Ansible are stateless: each time a module runs, it first checks the current state of the target system and then applies only the changes necessary to reach the desired state.

Ansible ships with many built-in modules, including:

• apt: Manages packages on Debian-based distributions (e.g., Ubuntu, Debian).
• yum: Manages packages on Red Hat–based distributions (e.g., RHEL, CentOS, Fedora).
• copy: Copies files from the control node to target hosts.
• shell: Executes arbitrary shell commands on target hosts.

These modules can be invoked either directly via the command line or declaratively within playbooks.

Example: Using the copy Module

Here’s a simple example using the copy module. Suppose you want to deploy an Nginx configuration file to your servers. You could write the following playbook:

---
- name: Copy configuration file
  hosts: web_servers
  tasks:
    - name: Copy nginx configuration
      copy:
        src: /path/to/local/nginx.conf
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: '0644'

In this example, we define a minimal playbook that uses the copy module to transfer the local nginx.conf file to /etc/nginx/nginx.conf on all target hosts, while also setting appropriate ownership and permissions.

Roles: Definition and Relationship to Modules

In Ansible, a role is a reusable, structured way to organize playbooks, tasks, modules, variables, and files. Roles help modularize complex configuration management workflows—making them easier to reuse, test, and maintain.

A typical role directory structure includes the following subdirectories:

• tasks/: Contains task definitions (often split across multiple files).
• handlers/: Defines handlers—special tasks triggered by notifications (e.g., restarting a service).
• templates/: Stores Jinja2 template files used for dynamic content generation.
• files/: Holds static files to be copied to target hosts.
• vars/: Contains variable definitions scoped to the role.

Roles are tightly coupled with modules: tasks inside a role frequently invoke one or more modules to achieve their goals. We’ll explore role creation and usage in detail in the next article.

Summary

In this article, we introduced the core concept of Ansible modules and demonstrated how to use them to manage infrastructure. We also outlined the purpose of roles and explained how they integrate with modules to support scalable, maintainable automation.

In the next article, we’ll walk through creating and using roles—taking our automation further by organizing tasks into well-defined, reusable components.

Through this tutorial series, we hope you’ll progressively master Ansible’s powerful capabilities—and build efficient, reliable infrastructure automation workflows.