How to Configure Apache Containers with Docker on Fedora 22

In this article we are going to learn about Docker, how to use it to deploy Apache httpd and how can you share it on Docker Hub. First we are going to learn how to pull and use images hosted on Docker Hub, and then install Apache on an image of Fedora 22 interactively, after that we are going to learn how to use a Dockerfile to make an image in a faster and more elegant way, finally we are going to publish the image we've created in Docker Hub, so anyone will be able download and use it later.

Installing Docker and saying hello world


You will need atleast these things to run Docker:

  • You need a 64bit Kernel version 3.10 or higher
  • Iptables 1.4 - This will be used by Docker to make the network wizardry, such as Network Address Translation.
  • Git 1.7 - Docker uses Git to make it transactions to repositories, like Docker Hub
  • ps - This utility is present in most environments and is provided in the procps package.
  • root - despite normal users can run docker client by TCP and other means, we will assume that you are root, for sake of simplicity

Install docker using dnf

The following commands will install Docker

dnf update && dnf install docker

Note: You can still use Yum in Fedora 22, but it's deprecated in favor of DNF and is not present in a clean install.

Check your install

The first command we are going to use is docker info, this give you many information:

docker info

Also try docker version:

docker version

Starting Docker as daemon

You should start a docker instance that will take care of our requests.

docker -d

Now set docker to start with the system, so you don't need to run the previous command every time you reboot.

chkconfig docker on

Let's say hello world with Busybox:

docker run -t busybox /bin/echo "hello world"

In this command, we tell Docker to execute /bin/echo "hello world" in an instance/container of the Busybox image, which is a minimal POSIX environment based in a single binary and links to it.

If Docker can't find a local image of Busybox on your system, it will pull the image automatically from Docker Hub, as you can see in the following screenshot:

Hello world with Busybox
Hello world with Busybox

Try the same command again, this time as Docker already have the Busybox image locally, all you will see is the output of echo:

docker run -t busybox /bin/echo "hello world"

Try also the following to enter in the container environment:

docker run -it busybox /bin/sh

To leave and stop the container use the exit command

Dockerizing Apache interactively

Pull/Download the Fedora image:

docker pull fedora:22

Run a container dettached from the console:

docker run -d -t fedora:22 /bin/bash

List running containers and identify by name as follows

docker ps
listing with docker ps and attaching with docker attach

The name angry_nobel was given to our instance, so let's attach:

docker attach angry_nobel

Note: Every time you run a container a new name will be given, if you need a constant name for you container you should use the -name parameter to docker run command.

Installing Apache

The following command will update DNF database, download install Apache (httpd package) and clean DNF cache to make the image small

dnf -y update && dnf -y install httpd && dnf -y clean all

Configuring Apache

The only thing we are going to change httpd.conf is the ServerName, this makes Apache stops to complain.

sed -i.orig 's/#ServerName/ServerName/' /etc/httpd/conf/httpd.conf

Set the environment

To make Apache run in standalone mode, you must provide some information in the form of enviroenment variables, and also you will need the directories set in these variables, so we are going to make this with a small shell script that will also start Apache

vi /etc/httpd/run_apache_foreground

#set variables

#create directories if necessary
if ! [ -d /var/run/httpd ]; then mkdir /var/run/httpd;fi
if ! [ -d /var/log/httpd ]; then mkdir /var/log/httpd;fi
if ! [ -d /var/lock/httpd ]; then mkdir /var/lock/httpd;fi

#run Apache

Alternatively, you can past and run this snippet on the container shell:

dnf -y install git && git clone && cd run-apach* && ./install && dnf erase git

The inline script above will, install Git, clone this repository, put the script in place and ask you if you want uninstall Git.

Saving your container state

Your container is now ready to run Apache, now it is time to save the current state of this container in an image to be able use whenever you need.

To leave the container environment, you must press Ctrl+p followed by Ctrl+q, if you just call exit in the shell, you will also stop the container and lost what you have done so far.

Once you are back to the Docker host, use docker commit followed by the container and the repository name/tag you desire:

docker commit angry_nobel gaiada/apache

Now that you saved the container status into a image, you can use docker stop on the running container:

docker stop angry_nobel

Run and test your image

Finally, run a container from your new image and redirect connections on port 80 to it with:

docker run -p 80:80 -d -t gaiada/apache /etc/httpd/run_apache_foreground

At this point, you are already running Apache in your container, open your browser to access the service in http://localhost and you will see the Apache default page as follows

Apache default page running from Docker container
Apache default page running from Docker container

 Dockerizing Apache with a Dockerfile

Now we are going to create a new Apache image, this time the steps will be written in a Dockerfile, that will be processed to form the image.

First, create a directory on which we will put the Dockerfile and enter this directory:

mkdir apachedf; cd apachedf

And then create a file named Dockerfile with the following content:

FROM fedora:22

MAINTAINER Carlos Alberto
LABEL version="0.1"

RUN dnf -y update && dnf -y install httpd && dnf -y clean all

RUN [ -d /var/log/httpd ] || mkdir /var/log/httpd
RUN [ -d /var/run/httpd ] || mkdir /var/run/httpd
RUN [ -d /var/lock/httpd ] || mkdir /var/lock/httpd

RUN sed -i.orig 's/#ServerName/ServerName/' /etc/httpd/conf/httpd.conf

ENV APACHE_LOG_DIR /var/log/httpd
ENV APACHE_LOCK_DIR /var/lock/httpd
ENV APACHE_RUN_DIR /var/run/httpd
ENV APACHE_PID_FILE /var/run/httpd/


CMD ["/usr/sbin/httpd", "-D", "FOREGROUND"]

Let's see what is on this Dockerfile:

FROM - This tells docker that we are going to use Fedora 22 as base image

MANTAINER and LABEL - these commands are informative and have no direct influence on the image

RUN - Automate the steps we've done interactively, install Apache, create directories and edit httpd.conf

ENV - Set the environment variables, now we don't need the run_apache_foreground script anymore.

EXPOSE - Expose the port 80 to the world

CMD - Set the default command to httpd, so we don't need to do this every time we start a new container

Build the image
Now we are going to build the image and put the TAG gaiada/apachedf on it:

docker build -t gaiada/apachedf:0.1 .
docker build complete
docker build complete

Use docker images list the local images and see if your new image is there:

docker images

And then run you new image:

docker run -t -p 80:80 gaiada/apachedf

That is it for the Dockerfile, using this feature make things much easier, faster and reproducible.

Publishing your images

Until now, you just pulled images from Docker Hub, but you can also push you image and pull them later as needed. In fact other can also download your image and use it in their systems without the need of change anything and now we are going to learn how to make our image available for others worldwide.

Creating account

For you to be able to push your image on Docker Hub, you need to create an account. Access and fill the following form:

Docker Hub signup page
Docker Hub signup page


Enter the following command and proceed with the login name, password and email you provided in your account creation

docker login

After you do the first login, your account information will be recorded in ~/.dockercfg


Push the page to the server with the docker push [registry/]your_login/repository_name[:tag]

docker push

You might see something like this on your console:

Docker push Apache image complete
Docker push Apache image complete


Now that you know how to Dockerize Apache, try to include some modules, Perl, PHP, proxy, HTTPS, or whatever you need. I hope you guys liked it, and push your own images on Docker Hub.

Leave a Comment