Ansible Docker Container Management Playbooks

Two very powerful free and open-source solutions that you may have heard about already are Ansible and Docker. What are these tools? How can you use them? Also, how can you use them together? Let’s look at Ansible Docker container management playbooks and see how we can manage Docker containers with Ansible automation.

What is Docker?

Docker is a popular open-source platform for creating, deploying, and managing containerized applications. It provides a simple architecture for packaging software and its dependencies into lightweight, portable containers that can run consistently across different environments. These lightweight application images can be downloaded from the Docker hub.

Docker containers can be executed on any system with Docker Engine installed, making it an ideal choice for developers and sysadmins looking to streamline application deployment and infrastructure management.

Installing Docker in Ubuntu 22.04

Before using Docker with your Ansible environment, you must install Docker and Docker Compose (optional) on your local machine. Docker compose allows you to construct your Docker deployments using YAML files. The installation process for Docker in Ubuntu 22.04 is straightforward. First, update the package manager:

sudo apt-get update

Next, install the required dependencies:

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

Add Docker’s official GPG key:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Add the Docker repository to your Ubuntu system:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Update the package manager again:

sudo apt-get update

Finally, install Docker:

sudo apt-get install docker-ce

To verify that Docker has been installed successfully, run:

sudo docker --version

Installing Docker in Other Linux Distributions

While we have covered installing Docker in Ubuntu 22.04, it’s important to note that Docker can also be installed on other Linux distributions. For example, on CentOS or RHEL-based systems, you would use the yum package manager instead of apt. The process remains quite similar, and Ansible playbooks can still be used to automate the installation and management of Docker on these systems.

What is Ansible?

Ansible is an open-source configuration management and automation tool for cloud provisioning, application deployment, and other infrastructure-related tasks. It uses a simple, human-readable language (YAML) to facilitate writing automation scripts called playbooks.

Ansible connects to remote servers via SSH and executes tasks defined in playbooks. Its agentless design and modular architecture make it a powerful and flexible solution for managing complex infrastructure.

What Does a Playbook do?

An Ansible playbook is a YAML file that defines a series of tasks to be executed on one or more remote servers. Playbooks can automate various tasks, such as installing software, creating and managing containers, and configuring system settings.

They provide a reusable and maintainable way to manage infrastructure, allowing users to describe the desired state of their systems clearly and concisely.

Why automate Docker containers with Ansible?

Automating Docker container management with Ansible offers several benefits. I am a huge fan of automation and configuration management and also a huge fan of Ansible. It brings a lot of benefits to managing Docker, such as:

Simplicity: Ansible’s simple and human-readable language (YAML) makes it easy to understand and maintain automation scripts for Docker containers.
Consistency: Using Ansible playbooks ensures your Docker containers are configured and managed consistently across multiple environments.
Scalability: Ansible can manage many containers and hosts, making it suitable for complex, large-scale deployments.
Flexibility: Ansible’s modular design and an extensive collection of built-in modules allow you to customize and extend your automation workflows to meet your specific needs.

How to Use Ansible With Docker?

Before you can start using Ansible with Docker, ensure that both Docker and Ansible are installed on your local machine. Once they are installed, you can create a playbook to automate the management of your Docker containers.

Managing Docker Containers Using Ansible Modules

Ansible provides several modules for managing Docker containers and images, such as docker_container, docker_image, and docker_network. These modules allow you to perform various tasks, such as creating, starting, stopping, and removing containers, building and managing images, and managing Docker networks.

Adding Packages Installation Tasks to your Playbook

To install packages using Ansible, you can use the apt module for Ubuntu and other Debian-based systems or the yum module for CentOS and other RHEL-based systems. Add the following tasks to your playbook to ensure that the required packages are installed:

- name: Install required packages
  apt:
    name: "{{ item }}"
    state: present
  loop:
    - apt-transport-https
    - ca-certificates
    - curl
    - software-properties-common

Build the Docker Image

To build a Docker image using an Ansible playbook, use the docker_image module. Add the following task to your playbook:

- name: Build Docker image
  docker_image:
    name: my_image
    path: /path/to/dockerfile
    state: present

Replace /path/to/dockerfile with the path to your Dockerfile, and my_image with your desired image name.

Adding Docker Installation Tasks to your Playbook

Add the following tasks to your playbook to install Docker on your target hosts:

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

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

- name: Update apt cache and install Docker
  apt:
    name: docker-ce
    update_cache: yes
    state: present

Adding Docker Image and Container Tasks to your Playbook

Add tasks that use the docker_image and docker_container modules to manage Docker images and containers using Ansible. For example:

- name: Pull Docker image
  docker_image:
    name: my_image
    source: pull
    state: present

- name: Create and run Docker container
  docker_container:
    name: my_container
    image: my_image
    state: started

Running your Playbook

To execute your Ansible playbook, run the following command:

ansible-playbook my_playbook.yml

Replace my_playbook.yml with the name of your playbook file.

Run your Docker image with Ansible

To run a Docker container from a specific image using Ansible, use the docker_container module. Add the following task to your playbook:

- name: Run Docker container
  docker_container:
    name: my_container
    image: my_image
    state: started

Application Deployment

Ansible playbooks can automate containerized application deployment to various environments: development, staging, and production. You can easily manage complex tasks using Ansible’s built-in modules and features, like rolling updates and zero-downtime deployments.

Ansible Modules for Docker management

Once you have Ansible installed, you can install Ansible modules. Some of the most commonly used Docker modules in Ansible include the following:

docker_container: Manages Docker containers, including creating containers and running containers
docker_image: Manages Docker images from which you create containers
docker_network: Manages Docker networks.
docker_volume: Manages Docker volumes.

The Docker module examples provide a robust set of tools for automating the management of your Docker infrastructure.

Scaling with Ansible and Docker

One significant advantage of using Ansible with Docker is the ability to scale your infrastructure easily. With Ansible, you can automate the provisioning and deployment of new Docker containers as your application grows. This allows you to respond to increased demand quickly and efficiently, ensuring your services remain performant and reliable, even under heavy load.

Scaling Containers Horizontally

Horizontal scaling refers to adding more instances of your application to your infrastructure to handle increased traffic. This can be done using Ansible by automating the creation of new Docker containers and deploying them to your infrastructure.

To scale your containers horizontally, you can use Ansible’s built-in scale attribute in conjunction with the docker_container module. For example:

- name: Scale Docker containers
  docker_container:
    name: my_container
    image: my_image
    state: started
    scale: 5

This task would ensure that there are five instances of the my_container container running based on the my_image image.

Scaling Containers Vertically

Vertical scaling refers to increasing the resources available to your application instances, such as CPU, memory, or storage. Ansible can also help you automate this process by modifying the resource limits of your Docker containers.

To scale your containers vertically, you can use the docker_container module’s resource allocation options, such as memory, cpus, or blkio_weight. For example:

- name: Increase container resources
  docker_container:
    name: my_container
    image: my_image
    state: started
    memory: 2g
    cpus: 2

This task would configure the my_container container to use 2 GB of memory and two CPU cores.

Monitoring and Logging with Ansible and Docker

Managing a large-scale containerized environment requires effective monitoring and logging to ensure optimal performance and troubleshooting issues. Ansible and Docker can work together to simplify these tasks and provide greater visibility into your containerized applications.

Monitoring Docker Containers

Ansible can automate the deployment of monitoring tools that integrate with Docker, such as Prometheus or Grafana. Using Ansible playbooks to deploy these tools ensures that your monitoring infrastructure remains consistent and up-to-date.

To deploy a monitoring tool using Ansible, you would create a playbook that installs the required software, configures the tool to monitor your Docker containers, and starts the monitoring service. This can be done using Ansible’s built-in modules and tasks, similar to the examples in this post.

Logging Docker Containers

Logging is an essential aspect of managing containerized applications. Docker provides built-in logging capabilities that can be configured and managed using Ansible playbooks. You can ensure that your logging infrastructure remains consistent and up-to-date by automating the deployment and configuration of logging tools, such as Elasticsearch, Logstash, and Kibana (ELK stack).

To deploy a logging tool using Ansible, you would create a playbook that installs the required software, configures the tool to collect logs from your Docker containers, and starts the logging service. This can be done using Ansible’s built-in modules and tasks, similar to the earlier examples.

Ensuring Security with Ansible and Docker

Security is a crucial aspect of managing containerized applications. Ansible and Docker can be used together to ensure that your containers are secure and compliant with best practices.

Updating Docker Images and Containers

Maintaining a secure environment is essential to keeping your Docker images and containers up-to-date. Ansible can automate updating your images and containers by pulling the latest image versions and redeploying your containers.

To update your Docker images and containers using Ansible, you can create a playbook with tasks to pull the latest images and restart the containers. For example:

- name: Update Docker images
  docker_image:
    name: my_image
    state: latest

- name: Restart Docker containers
  docker_container:
    name: my_container
    image: my_image
    state: started
    recreate: yes

These tasks would ensure that your my_image image is updated to the latest version and that the my_container container is recreated using the updated image.

Implementing Security Best Practices

Ansible playbooks can also be used to implement security best practices for your Docker containers, such as ensuring proper network segmentation, limiting container privileges, and using secure communication channels.

To implement security best practices with Ansible, you can create tasks configuring your Docker containers according to the desired security guidelines. For example, you might create a task that configures a container to run with a non-root user or one that enforces the use of encrypted communication protocols.

Continuous Integration and Deployment with Ansible and Docker

Ansible and Docker can be integrated with continuous integration (CI) and continuous deployment (CD) pipelines to automate your containerized applications’ build, test, and deployment. By leveraging Ansible playbooks in your CI/CD workflows, you can ensure your applications are consistently built, tested, and deployed according to your desired specifications.

Integrating Ansible with CI Tools

Ansible playbooks can be used with popular CI tools like Jenkins, GitLab CI, or Travis CI to automate your application development lifecycle’s build and test phases. By incorporating Ansible tasks in your CI pipeline, you can create reusable, version-controlled automation scripts that streamline your build and test processes.

To integrate Ansible with your CI tool, you would create a playbook that includes tasks for building and testing your application and then configure your CI tool to execute the playbook as part of its build and test stages.

Automating Deployment with CD Tools

Ansible can also be used with CD tools, such as Jenkins, GitLab CI, or Spinnaker, to automate the deployment of your containerized applications. By incorporating Ansible tasks in your CD pipeline, you can create reusable, version-controlled automation scripts that streamline your deployment processes.

To integrate Ansible with your CD tool, you would create a playbook that includes tasks for deploying your application to your target environment and then configure your CD tool to execute the playbook as part of its deployment stages.

Wrapping up

You can manage entire environments using Ansible playbooks, including provisioning cloud infrastructure, configuring bare metal servers, and deploying containerized applications. Ansible’s modular design and extensive collection of built-in modules make it an ideal solution for efficiently managing complex, multi-tiered environments.

Ansible and Docker are robust tools for automating container management and application deployment. By combining Ansible’s flexibility and ease of use with Docker’s containerization capabilities, you can streamline your infrastructure management and improve the consistency and reliability of your deployments. The integration of Ansible and Docker enables you to manage complex tasks, deploy applications across multiple platforms, and maintain a clear and maintainable infrastructure configuration.

IT World