In this section, we will explore how Ansible can be used to manage Docker containers. Docker is a platform that allows you to automate the deployment, scaling, and management of applications inside lightweight containers. Ansible, on the other hand, is a powerful automation tool that can help you manage your Docker containers efficiently.

By the end of this section, you will:

• Understand the basics of Docker.
• Learn how to use Ansible to manage Docker containers.
• Write Ansible playbooks to automate Docker tasks.

Before you start, ensure you have:

• Basic knowledge of Docker.
• Ansible installed on your system.
• Docker installed on your system.

Docker is a platform designed to make it easier to create, deploy, and run applications by using containers. Containers allow a developer to package up an application with all parts it needs, such as libraries and other dependencies, and ship it all out as one package.

Using Ansible with Docker allows you to:

• Automate the deployment of Docker containers.
• Manage Docker images and containers.
• Ensure consistency across different environments.

If you haven't installed Docker yet, you can follow the official Docker installation guide for your operating system: Docker Installation Guide.

Ansible provides several modules to manage Docker. Some of the key modules include:

• docker_container: Manage the lifecycle of Docker containers.
• docker_image: Manage Docker images.
• docker_network: Manage Docker networks.
• docker_volume: Manage Docker volumes.

Create an inventory file named hosts with the following content:

Create a playbook named docker_playbook.yml with the following content:

Execute the playbook using the following command:

• Ensure Docker is installed: This task ensures that Docker is installed on the system using the apt module.
• Start Docker service: This task starts the Docker service and ensures it is enabled to start on boot using the service module.
• Pull the latest nginx image: This task pulls the latest nginx image from Docker Hub using the docker_image module.
• Run an nginx container: This task runs an nginx container and maps port 80 of the container to port 80 of the host using the docker_container module.

1. Objective: Create a Dockerized web application using Ansible.
2. Steps:
   • Create a Dockerfile for a simple web application.
   • Write an Ansible playbook to build the Docker image and run the container.
3. Solution:
   • Dockerfile:

     FROM python:3.8-slim
     WORKDIR /app
     COPY . /app
     RUN pip install -r requirements.txt
     CMD ["python", "app.py"]
     

   • Ansible Playbook:

     ---
     - name: Dockerized Web Application
       hosts: local
       tasks:
         - name: Ensure Docker is installed
           apt:
             name: docker.io
             state: present
           become: yes
     
         - name: Start Docker service
           service:
             name: docker
             state: started
             enabled: yes
           become: yes
     
         - name: Build the Docker image
           docker_image:
             name: web_app
             build:
               path: /path/to/your/app
     
         - name: Run the web application container
           docker_container:
             name: web_app_container
             image: web_app
             state: started
             ports:
               - "5000:5000"
     

• Ensure Docker is running: Make sure the Docker service is running before executing Docker-related tasks.
• Correct paths: Ensure the paths specified in the playbook (e.g., for the Dockerfile) are correct.
• Permissions: Use become: yes to run tasks that require elevated permissions.

In this section, you learned how to use Ansible to manage Docker containers. You wrote a playbook to automate the installation of Docker, pull Docker images, and run Docker containers. This knowledge will help you efficiently manage your Dockerized applications using Ansible.

Next, we will explore how Ansible can be used to manage Kubernetes in the following section.