Docker Management Using Ansible

Overview

This documentation explains how to use Ansible to manage Docker containers across multiple hosts, automating tasks such as starting, stopping, and removing containers. Ansible’s capabilities provide a powerful and consistent method for handling Docker operations, which can be scaled to manage large infrastructure deployments.

Benefits of Using Ansible for Docker Management

Ansible offers several advantages when managing Docker:

• Consistency: Ensures container configurations remain consistent across environments.

• Automation: Reduces manual intervention for starting, stopping, and configuring containers.

• Scalability: Easily scales to manage containers across multiple hosts.

• Integration: Integrates Docker management with CI/CD or other infrastructure automation workflows.

• Simplicity: Uses YAML playbooks that are easy to write, read, and maintain.

Prerequisites

To follow this guide, ensure you have the following:

1. Docker installed on the target system(s).

2. Ansible installed on your control machine:

    pip install ansible
   

3. Ansible Docker modules: Install the docker-py and Docker SDK for Python.

    pip install docker
   

4. Ansible Inventory Configuration: Configure your Ansible inventory to include the Docker hosts you plan to manage.

Setting Up

Follow these steps to automate Docker management using Ansible.

Step 1: Define Inventory File

The inventory file specifies the target hosts where Docker operations will be performed. Create an inventory file (hosts) and add the target host(s):

[docker_hosts]
localhost  ansible_connection=local

This configuration targets Docker running locally. For remote Docker hosts, add them here and adjust ansible_connection and SSH details as needed.

Step 2: Create the Ansible Playbook for Docker Management

Ansible playbooks are YAML files that define tasks. The playbook below (docker-management.yml) includes tasks for starting, stopping, removing, and running Docker containers.

Sample Playbook: docker-management.yml

---
- name: Docker Container Management
  hosts: docker_hosts
  tasks:

    - name: Start an Nginx container
      docker_container:
        name: my_nginx_container
        image: nginx
        state: started
        restart_policy: always
        ports:
          - "80:80"

    - name: Stop the Nginx container
      docker_container:
        name: my_nginx_container
        state: stopped

    - name: Remove the Nginx container
      docker_container:
        name: my_nginx_container
        state: absent

    - name: Run a new container with a custom command
      docker_container:
        name: my_alpine_container
        image: alpine
        state: started
        command: "echo Hello from Ansible!"

Step 3: Run the Playbook

Execute the playbook using the command below:

ansible-playbook -i hosts docker-management.yml

This command tells Ansible to execute docker-management.yml against the hosts specified in the hosts inventory file.

Playbook Breakdown

Task 1: Starting a Container

The following task starts an Nginx container called my_nginx_container. This container maps port 80 on the host to port 80 in the container, with an automatic restart policy:

- name: Start an Nginx container
  docker_container:
    name: my_nginx_container
    image: nginx
    state: started
    restart_policy: always
    ports:
      - "80:80"

Task 2: Stopping a Container

This task stops the container my_nginx_container if it is running:

- name: Stop the Nginx container
  docker_container:
    name: my_nginx_container
    state: stopped

Task 3: Removing a Container

This task removes my_nginx_container if it exists. This is useful for cleaning up unneeded containers:

- name: Remove the Nginx container
  docker_container:
    name: my_nginx_container
    state: absent

Task 4: Running a New Container with a Custom Command

This task creates and starts an Alpine Linux container that executes a custom command:

- name: Run a new container with a custom command
  docker_container:
    name: my_alpine_container
    image: alpine
    state: started
    command: "echo Hello from Ansible!"

Extending Docker Management with Ansible

Pulling Docker Images

You can pull Docker images from Docker Hub before running them. For example:

- name: Pull the latest Nginx image
  docker_image:
    name: nginx
    source: pull

Running Multiple Containers

To start multiple containers, use a loop in the playbook with with_items:

- name: Start multiple containers
  docker_container:
    name: "{{ item.name }}"
    image: "{{ item.image }}"
    state: started
  with_items:
    - { name: "nginx_container", image: "nginx" }
    - { name: "redis_container", image: "redis" }

Monitoring Docker Logs

You can view the logs of a Docker container by using the shell module to run a docker logs command:

- name: Monitor Docker logs
  shell: docker logs my_nginx_container

Building Docker Images

To build a Docker image from a Dockerfile, specify the path to the Dockerfile:

- name: Build Docker image from Dockerfile
  docker_image:
    path: /path/to/Dockerfile
    name: my_custom_image

Benefits of Using Ansible for Docker Automation

Ansible provides powerful advantages for Docker management:

1. Consistency: Playbooks ensure container configurations are applied uniformly across environments.

2. Automation: Routine tasks like container deployment, removal, and updates are handled automatically.

3. Scalability: Ansible’s inventory system allows you to target multiple Docker hosts, making it easy to scale container management.

4. Ease of Use: Ansible’s YAML syntax makes the playbooks simple to understand and maintain.

5. Integration: Ansible playbooks integrate seamlessly with other automation pipelines (e.g., CI/CD), making it ideal for complex workflows.

Conclusion

Using Ansible to manage Docker containers allows for effective automation, consistency, and scalability across environments. With Ansible, container operations such as starting, stopping, and creating containers are streamlined, reducing human error and manual effort. This playbook can serve as a template for more advanced container management tasks, whether in development, staging, or production environments.