Apache Httpd Webserver configuration on Docker using Ansible(by updating inventory with container’s IP)


Configuration of Apache Httpd Webserver on Docker container using Ansible by dynamic addition of container’s IP address to the inventory file.

Content of this Blog

  • Prerequisite
  • Project Understanding : Ansible Roles Setup
  • Output


  • For Ansible, refer the following link:
  • For Docker, refer the following link:
  • For Apache Http, refer the following link:

Project Understanding : Ansible Roles Setup

Let’s understand each Ansible role implementation one by one

Part 1: Ansible Role (container_creation)

tasks : main.yml

# tasks file for container_creation
- name: Mount Directory Creation
state: directory
path: "{{ mount_directory }}"
- name: Mount Directory to CDROM
src: "/dev/cdrom"
path: "{{ mount_directory }}"
state: mounted
fstype: "iso9660"
- name: Yum Repository - AppStream
baseurl: "{{ mount_directory }}/AppStream"
name: "dvd1"
description: "Yum Repository - AppStream"
enabled: true
gpgcheck: no
- name: Yum Repository - BaseOS
baseurl: "{{ mount_directory }}/BaseOS"
name: "dvd2"
description: "Yum Repository - BaseOS"
enabled: true
gpgcheck: no
- name: Docker Repository Setup
name: "docker"
description: "Docker Repository"
enabled: true
gpgcheck: no
- name: Check whether Docker is installed or not
command: "rpm -q docker-ce"
register: docker_check
- name: Docker Installation
command: "yum install docker-ce --nobest -y"
when: '"is not installed" in docker_check.stdout'
- name: Starting Docker Service
name: "docker"
state: started
enabled: yes
- name: Python3 Installation
name: "python36"
state: present
- name: Installation of Docker SDK for Python
name: "docker-py"
- name: Changing SELinux state to permissive
policy: targeted
state: permissive
- name: Stopping Firewall
name: "firewalld"
state: stopped
- name: DockerHub Login
username: "{{ dockerhub_username }}"
password: "{{ dockerhub_password }}"
- name: Build Directory Creation
path: /root/dockerfile
state: directory
- name: Copying Dockerfile to the Build Directory
src: files/Dockerfile
dest: /root/dockerfile/Dockerfile
- name: Building Image from Dockerfile and pushing it to DockerHub
path: /root/dockerfile
name: "{{ dockerhub_username }}/centos_ssh"
tag: v1
push: yes
source: build
- name: Creation of container from the image created
name: centos_ssh_container
image: "{{ dockerhub_username }}/centos_ssh:v1"
pull: yes
detach: yes
state: started
- "{{ port_number }}:80"
register: container_info
- name: Retrieving Container IP
shell: echo '{{container_info["ansible_facts"]["docker_container"]["NetworkSettings"]["IPAddress"] }}'
register: container_ip
- name: Adding Container IP to the inventory file
src: templates/inventory.yml
dest: /etc/inventory.yml
- name: Removing EDCSA key from known_hosts file
path: /root/.ssh/known_hosts
state: absent
regexp: "ecdsa-sha2-nistp256"

Important Points

  • Mount directory is created along with repository for Yum and Docker.
  • Docker is installed and respective service are enabled.
  • Python 3.6 is installed, also Python SDK for Docker is installed as it is required for usage of Docker modules in Ansible.
  • SELinux state is changed to permissive to avoid hindrance in Docker container creation using Ansible modules. Also Firewall is disabled so web page to be set up in the next part could be accessed from outside as well.
  • Docker image are built using Dockerfile(mentioned below) and then pushed to DockerHub. Container from the same is created with SSH connectivity set up within it, also port 80 used for webserver is exposed using the concept of PAT(Port Address Translation).
  • Container’s IP address is retrieved and dynamically placed in the inventory file. Also EDCSA key is removed from known_hosts file present in Docker Host to avoid issues in accessing the new container generated via SSH for Ansible.

Note: In order to use “community.docker.docker_image” module, run the command mentioned below:

ansible-galaxy collection install community.docker

files : Dockerfile

FROM centos:latest
RUN yum install openssh-server -y
RUN echo "PasswordAuthentication yes" >> /etc/ssh/sshd_config
RUN echo "root:centos" | chpasswd
RUN ssh-keygen -A
CMD ["/usr/sbin/sshd","-D"]

Important Points

  • CentOS is used as base image and openssh-server is installed to set up SSH.
  • Password Authentication is enabled and mentioned in SSH configuration file.
  • Password value is mentioned i.e., “centos” and generates host keys using ssh-keygen.
  • sshd service is enabled and port 22 is exposed.

vars : main.yml

# vars file for container_creation
mount_directory: "/dvd1"
dockerhub_username: XXXX
dockerhub_password: XXXX
port_number: "80"

Important Points

  • Name of directory to be mounted is mentioned.
  • Username and password required to login to DockerHub so as to push the image created is mentioned.
  • Port number is mentioned for PAT(Port Address Translation) for the Apache Httpd webserver setup within the container.

templates : inventory.yml

{{ container_ip.stdout }} ansible_ssh_user=root ansible_ssh_pass=centos

Important Points

  • container_ip” variable is mentioned in the file using Jinja2 templating.
  • The value of the variable is obtained by retrieving the IP address of container created.

— — — — — — — — — — — — — — — — — — — — — — — — —

Part 2: Ansible Role (container_webserver_setup)

tasks : main.yml

# tasks file for container_webserver_setup
- name: Httpd Installation
name: "httpd"
state: present
register: httpd_install_status
- name: Web Page Setup
dest: "/var/www/html/index.html"
src: "files/index.html"
- name: Starting Httpd Service
command: "/usr/sbin/httpd"
changed_when: httpd_install_status.changed == true

Important Points

  • httpd is installed in the container accessed via SSH by the Ansible using the inventory file updated in the previous role after container is created.
  • Webpage to be accessed via webserver are copied from the files directory to the Document Root within the container.
  • httpd service is enabled only when the state of “Httpd Installation” changes.

files : index.html

<b>Hello from Container</b>


Usage of Virtual Machine’s IP Address to access the web page launched within Docker container
curl command used to access the content of web page using Docker container’s IP within Virtual Machine




Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

No Time Like ThePresent https://t.co/ca5OtuHj84 https://t.co/4H1lP4ubMq

Baseline machine VS comprimised one

Adobe Commerce Magento 2.4 vs Sylius a Symfony based eCommerce Framework

Automating the boring stuff in Django using the check framework

The Default APY for Our Staking Portal will Decrease from 30% to 18%

Connection Assets with Decision Optimization on Watson Machine Learning

5 Best C# (C-Sharp) Online Courses for Beginners in 2022

6 Best C# (C-Sharp) Online Courses for Beginners

11 SQL Query Optimization Techniques commonly used in Projects

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Satyam Singh

Satyam Singh

More from Medium

Automate Kubernetes Cluster Using Ansible

Install Open LDAP Server / Console via Helm Chart

Configure Vulnerability Scanning on Compute in Oracle Cloud

How I build a crypto bot with Python, Docker, Rancher, Azure Devops and ArgoCD