Mastering Ansible for Seamless Docker Installation and Configuration

Forget complicated manual setups—discover how a precise, idempotent Ansible playbook can replace error-prone scripts to install Docker effortlessly and reliably every single time.

If you’ve ever set up Docker manually on multiple servers, you know the pain: missed dependencies, version mismatches, or simply inconsistent environments. Automating Docker installation with Ansible not only slashes setup time but also guarantees consistency. Whether you manage a handful of servers or scale to hundreds, an Ansible-driven approach turns what was once tedious into a one-command operation.

Today, I’ll walk you through how to master Ansible for installing and configuring Docker on your Linux hosts. You’ll get a practical, ready-to-use playbook that is idempotent—meaning you can run it repeatedly without worrying about breaking anything.

Why Automate Docker Installation With Ansible?

• Consistency: Every server gets the exact same version and configuration.
• Speed: Setup multiple machines at once with parallel execution.
• Reliability: No more manual errors or missing steps.
• Reproducibility: Easily replicate environments on new or recovery hosts.
• Maintainability: Centralized code for easy updates or customizations.

Prerequisites

• Ansible installed on your control node (ansible --version).
• SSH access to target Linux servers (tested here mainly on Ubuntu 20.04 / 22.04).
• A user with sudo privileges on the managed nodes.

Building the Ansible Playbook: Step-by-Step

Here’s a simple yet robust playbook to install and configure Docker Engine on Ubuntu servers.

1. Create your playbook file install-docker.yml

---
- name: Install and configure Docker Engine
  hosts: all
  become: true    # Escalate privileges where required
  tasks:
    - name: Ensure apt cache is updated
      apt:
        update_cache: yes

    - name: Install prerequisite packages
      apt:
        name:
          - ca-certificates
          - curl
          - gnupg
          - lsb-release
        state: present

    - name: Add Docker’s official GPG key
      ansible.builtin.apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

    - name: Add Docker apt repository
      apt_repository:
        repo: "deb [arch=amd64] https://download.docker.com/linux/ubuntu {{ ansible_lsb.codename }} stable"
        state: present

    - name: Update apt package index after adding repo
      apt:
        update_cache: yes

    - name: Install Docker Engine package
      apt:
        name:
          - docker-ce
          - docker-ce-cli
          - containerd.io
        state: latest

    - name: Ensure Docker service is started and enabled
      systemd:
        name: docker
        state: started
        enabled: true

    - name: Add current user to docker group (if applicable)
      user:
        name: "{{ ansible_user_id }}"
        groups: docker
        append: yes
      when: ansible_user_id != 'root'

Explanation:

• We update the apt cache at the start to get fresh package lists.
• We install necessary prerequisites like curl and gnupg.
• Add Docker’s official GPG key and set up the stable repository for your Ubuntu version dynamically using ansible_lsb.codename.
• Install latest stable versions of docker-ce packages.
• Make sure the Docker service starts at boot and runs now.
• Optionally adds your logged-in user to the docker group so they can run docker commands without sudo.

Running Your Playbook

Run this command from your control machine:

ansible-playbook -i your_inventory_file install-docker.yml

Replace your_inventory_file with the path to your hosts file listing IP addresses or hostnames of your managed nodes.

Verifying Installation

Once the playbook completes successfully, SSH into any managed host and run:

docker --version
docker run hello-world

You should see Docker’s version info and a successful “Hello from Docker!” message confirming everything worked.

Customizing Further

This playbook focuses on Ubuntu but can be adjusted for CentOS or Debian by tweaking repository URLs and package managers (yum instead of apt). You can also extend it with tasks that:

• Configure daemon options (e.g., custom registry mirrors).
• Manage firewall rules related to Docker.
• Install Compose plugins.

Ansible roles like geerlingguy.docker offer sophisticated out-of-the-box solutions too if you want more features.

Conclusion

Moving away from manual installations toward an automated, idempotent setup using Ansible lets you spend less time wrestling with configuration details and more time building awesome containerized apps. Once this playbook is in place, spinning up new servers with identical docker environments becomes a breeze.

Try this out on your next project setup—your future self will thank you!

Happy automating! 🚀

If you found this guide helpful, feel free to share or comment below. Got questions about extending it? Let me know!