MongoDB Docker Container Creation

FROM fedora:20
MAINTAINER Mark Lamourine
#COMMENT { "description": "mongodb service container",
# "usage": "docker run -d -p 27017:27017 --name mongodb mlamouri/mongodb --volume=/mydbdatadir:/var/lib/mongodb" }
RUN  yum install -y mongodb-server && yum clean all
RUN  mkdir -p /var/lib/mongodb &&
    touch /var/lib/mongodb/.keep &&
    chown -R mongodb:mongodb /var/lib/mongodb
ADD mongodb.conf /etc/mongodb.conf
VOLUME [ "/var/lib/mongodb" ]
EXPOSE 27017
USER mongodb
WORKDIR /var/lib/mongodb
ENTRYPOINT ["/usr/bin/mongod", "--config", "/etc/mongodb.conf"]
CMD ["--quiet"]

This is just what we need to create a MongoDB docker container image. Now it is very important to understand each and every line of the docker image configuration file, as a change to this will change the behavior of the docker container itself.

The explanation of the docker image configuration file has been adapted from the official Docker documentation.

• FROM refers to an existing image on an Official public docker registry. Here, in our case, Fedora is maintaining this and notes that if you skip adding version 20, then the latest version image will be made available. It is very much important to keep what is needed in a docker file and skip what is not needed.
• MAINTAINER refers to the maintainer of the image definition
• RUN indicates the command that needs to be executed on the base image. This will make changes or adds things that will be captured and create a new layer. The shell command that follows the RUN directive should be treated as a single line or else the shell escapes the command once the line exceeds 80 characters.
• This particular line installs the MongoDB-server package and after that, the YUM cache is cleared. Cleaning up after YUM eradicates chances of including cached RPMs and metadata from increasing the layer and thereby the image.
• The next set of RUN command prepares the directories for the MongoDB storage
• ADD directive adds the MongoDB.conf file to the container. This directive takes the file from the folder where the docker configuration file is residing and will overwrite the destination file on the container.
• VOLUME directive is a declaration that the folder /var/lib/MongoDB will be used as a mount point for external data storage.
• EXPOSE directive declares that the TCP port 21017 will be exposed for accepting connections from outside the container to access the hosted MongoDB instance inside it.
• USER directive mentions that the first command executed will be under the MongoDB user’s context.
• WORKDIR mentions that the command will run in /var/lib/MongoDB which is going to be the home directory for the MongoDB user here on.

CMD directive mentions the default command to execute when the container starts.

Checkout MongoDB Interview Questions

Building the Docker Image

With the Docker image configuration file and the MongoDB.conf template in the image directory, we are ready to build the image. Following is the transcript of the docker image creation.

docker build -t XXX/mongodb images/mongodb
Sending build context to Docker daemon 4.096 kB
Sending build context to Docker daemon
Step 0 : FROM fedora:20
Pulling repository fedora
88b42ffd1f7c: Download complete
511136ea3c5a: Download complete
c69cab00d6ef: Download complete
---> 88b42ffd1f7c
Step 1 : MAINTAINER Mark Lamourine
---> Running in 38db2e5fffbb
---> fc120ab67c77
Removing intermediate container 38db2e5fffbb
Step 2 : RUN  yum install -y mongodb-server &&      yum clean all
---> Running in 42e55f18d490
Resolving Dependencies
--> Running transaction check
---> Package mongodb-server.x86_64 0:2.4.6-1.fc20 will be installed
--> Processing Dependency: v8 for package: mongodb-server-2.4.6-1.fc20.x86_64
...
Installed:
 mongodb-server.x86_64 0:2.4.6-1.fc20                                          
...
Complete!

Cleaning repos: fedora updates

Cleaning up everything
---> 8924655bac6e
Removing intermediate container 42e55f18d490
Step 3 : RUN  mkdir -p /var/lib/mongodb &&      touch /var/lib/mongodb/.keep && shown -R mongodb:mongodb /var/lib/mongodb
---> Running in 88f5f059c3ff
---> f8e4eaed6105
Removing intermediate container 88f5f059c3ff
Step 4 : ADD mongodb.conf /etc/mongodb.conf
---> eb358bbbaf75
Removing intermediate container 090e1e36f7f6
Step 5 : VOLUME [ "/var/lib/mongodb" ]
---> Running in deb3367ff8cd
---> f91654280383
Removing intermediate container deb3367ff8cd
Step 6 : EXPOSE 27017
---> Running in 0c1d97e7aa12
---> 46157892e3fe
Removing intermediate container 0c1d97e7aa12
Step 7 : USER mongodb
---> Running in 70575d2a7504
---> 54dca617b94c
Removing intermediate container 70575d2a7504
Step 8 : WORKDIR /var/lib/mongodb
---> Running in 91759055c498
---> 0214a3fbcafc
Removing intermediate container 91759055c498
Step 9 : CMD [ "/usr/bin/mongod", "--quiet", "--config", "/etc/mongodb.conf", "run"]
---> Running in 6b48f1489a3e
---> 13d97f70aeb4
Removing intermediate container 6b48f1489a3e
Successfully built 13d97f70aeb4

A Docker container has a set of file trees that are layered using a read-only union filesystem with a read/write layer on the top. All the changes should go into the topmost layer.

When building a new image the changes for each directive are archived into a tarball and checksummed to produce the new layer and the layer's ID. This process is repeated for each directive, accumulating new layers until all of the directives have been processed.

The intermediate containers are deleted, the new layer files are saved and tagged. The end result is a new image (a set of new layers).

Checkout MongoDB Tutorial

The following is the simplest test that we can perform to check whether the newly created container is running or not.

docker run --name mongodb1 --detach --publish-all  XXX/mongodb
e90b275d00d451fda4add9bc99798e4487815e38c8efbe51bfde505c17d920eb

Running the command above indicates that the docker should run the image named XXX/MongoDB. This should actually detach and make all the network ports exposed by the container available to the host.

Names the container as mongodb1 just as we have mentioned it in the command above. The response to the command above is a hash of the currently running Docker container.

With the running container, we can safely assume that the MongoDB is running as well and waiting for a connection. Now how do we check that our service is up and running on the container? To list the running containers use docker ps.

docker ps

CONTAINER ID        IMAGE                      COMMAND                CREATED   
STATUS              PORTS                        NAMES

a90b275d00d4      XXX/mongodb:latest        /usr/bin/mongod --qu      5 mins ago
Up 5 min          0.0.0.0:49155->27017/tcp     mongodb1

With the docker container name or its id, we can query for the required port information from the docker itself. The command which helps gain this information is shown as below:

docker port mongodb1 27017

0.0.0.0:49155

The container port 23017 is forward to the host “all interfaces” port 49155. If the host firewall allows connections on that port, then the database could be compromised from outside

echo "show dbs" | mongo localhost:49155
MongoDB shell version: 3.4.7
connecting to: localhost:49155/test
local 0.03125GB
bye

Conclusion

If you’ve reached this point, then you can verify that you have a running MongoDB instance accessible from the host. If it is required to have this instance accessible outside of the container, then that can be achieved as well.

In this article, we have understood the specifics of Docker and how a Docker container can be created. We have also spent some time understanding how MongoDB can exist as a single container on Docker. We have seen how this can be achieved on a Linux machine, as Windows support for Docker is still in the budding stage.