In the previous chapter, we installed Docker on the following target operating systems:

• macOS High Sierra and above
• Windows 10 Professional
• Ubuntu 18.04

In this chapter, we will be using our Docker installation to build images. While the screenshots in this chapter will be from my preferred operating system, which is macOS, the Docker commands we will be running will work on all three of the operating systems on which we have installed Docker so far. However, some of the supporting commands, which will be few and far between, may only be applicable to macOS and Linux-based operating systems.

A full copy of the code used in this chapter can be found at: https://github.com/PacktPublishing/Mastering-Docker-Third-Edition/tree/master/chapter02

Check out the following video to see the Code in Action:

http://bit.ly/2D0JA6v

In this section, we will cover Dockerfiles in depth, along with the best practices to use. So what is a Dockerfile?

A Dockerfile is simply a plain text file that contains a set of user-defined instructions. When the Dockerfile is called by the docker image build command, which we will look at next, it is used to assemble a container image. A Dockerfile looks like the following:

FROM alpine:latest
LABEL maintainer="Russ McKendrick <russ@mckendrick.io>"
LABEL description="This example Dockerfile installs NGINX."
RUN apk add --update nginx && \
    rm -rf /var/cache/apk/* && \
    mkdir -p /tmp/nginx/

COPY files/nginx.conf /etc/nginx/nginx.conf
COPY files/default.conf /etc/nginx/conf.d/default.conf
ADD files/html.tar.gz /usr/share/nginx/

EXPOSE 80/tcp

ENTRYPOINT ["nginx"]
CMD ["-g", "daemon off;&quot...

In this section, we will cover the docker image build command. This is where the rubber meets the road, as they say. It's time for us to build the base upon which we will start building our future images. We will be looking at different ways to accomplish this goal. Consider this as a template that you may have created earlier with virtual machines. This will help save time by completing the hard work; you will just have to create the application that needs to be added to the new images.

There are a lot of switches that you could use while using the docker build command. So, let's use the always handy --help switch on the docker image build command to view all that we can do:

$ docker image build --help

There are then a lot of different flags listed that you can pass when building your image. Now, it may seem like a lot to digest, but out of...

In this chapter, we looked at an in-depth view of Dockerfiles, the best practices for writing them, the docker image build command, and the various ways we can build containers. We also learned about the environmental variables that you can use to pass from your Dockerfile to the various items inside your containers.

In the next chapter, now that we know how to build images using Dockerfiles, we will be taking a look at the Docker Hub and all of the advantages that using a registry service brings. We will also look at the Docker registry, which is open source, so you can roll your own place to store images without the fees of Docker Enterprise, as well as third-party registry services.

1. True or false: The LABEL instruction tags your image once it has been built?
2. What's the difference between the ENTRYPOINT and CMD instructions?
3. True or false: when using the ADD instruction, you can’t download and automatically uncompress an externally hosted archive?
4. What is a valid use for using an existing container as the base of your image?
5. What does the EXPOSE instruction expose?

You can find the guidelines for the official Docker container images at:

• https://github.com/docker-library/official-images/

Some of the tools to help you create containers from existing installations are the following:

• Debootstrap: https://wiki.debian.org/Debootstrap/
• Yumbootstrap: https://github.com/dozzie/yumbootstrap/
• Rinse: https://salsa.debian.org/debian/rinse/
• Docker contrib scripts: https://github.com/moby/moby/tree/master/contrib/

Finally, the full GitHub repository for the Go HTTP Hello World application can be found at:

• https://github.com/geetarista/go-http-hello-world/