2.1 Dockerfiles

The most common way to create an image is to use a Dockerfile, a text file that contains all the instructions necessary to build the image. The advantage of the Dockerfile is that it can be interpreted by the Docker engine, which makes the creation of images an automated and repeatable task.

Suppose that you want a quick way to download all the images from a Web page. You learn that a quick way is to use the almighty Linux commands and you find on the Web a Bash script that does exactly what you want:

#!/bin/bash
wget $1 -O page.html
grep -E "(https?:)?//[^/\s]+/\S+\.(jpg|png|gif|svg)" page.html -o | sed "s/(^https?)?\/\//https\:\/\//g" -r > urls.txt
sed -E "s/\/thumb//g; s/\/[0-9]+px-.+\.(jpg|png)$//g" urls.txt | uniq > urls-new.txt
wget -i urls-new.txt -P downloads/

Don’t worry if you don’t understand these instructions. Suffices to say that:

• The first instruction gets an URL as an argument ($1) and downloads the page pointed by the URL into a file called page.html.

• The second instruction extracts from page.html all the URLs pointing to images. The URLs are saved to a file called url.txt.

• The third instruction filters the URLs that point to full-size images. It saves the filtered URLs to a file called urls-new.txt.

• The fourth instruction downloads the full-size images to a folder named downloads.

You now create a folder in your computer named myfigures; you create a new text file that you name dlimages.sh and you save it under folder myfigures; you copy the above Bash script into the new file and you save it.

But now you wonder: how can you execute this script if you’re not using Linux?

The answer is: you can create a new Docker image (let’s call it dlimages) from the official Ubuntu image!

The Dockerfile containing the instructions to build the image dlimages is as follows:

FROM ubuntu
RUN apt-get update
RUN apt-get install -y wget
RUN mkdir -p /scripts
COPY dlimages.sh /scripts/dlimages.sh
RUN chmod +x /scripts/dlimages.sh
ENTRYPOINT ["/scripts/dlimages.sh"]
CMD ["https://en.wikipedia.org/wiki/Cat"]

Here’s the explanation:

1. We use the image ubuntu as the base image. This corresponds to the instruction FROM ubuntu.

2. We install the utility wget in the base image. This corresponds to the instructions RUN apt-get update and RUN apt-get install -y wget.

3. We create a directory scripts under the root directory of the image. This corresponds to the instruction RUN mkdir -p /scripts.

4. We copy the file dlimages.sh to the folder scripts in the image. This corresponds to the COPY instruction.

5. We specify that dlimages.sh can be executed. This corresponds to the RUN chmod -x instruction.

6. We specify the command to be executed when a container is run from this image. This corresponds to the instruction ENTRYPOINT. When we run a container from this image, we execute the script dlimages.sh.

7. We specify a default argument to be passed to the script. This corresponds to the instruction CMD.

FROM ubuntu
RUN apt-get update && \
    apt-get install -y wget && \
    mkdir -p /scripts
COPY dlimages.sh /scripts/dlimages.sh
RUN chmod +x /scripts/dlimages.sh
ENTRYPOINT ["/scripts/dlimages.sh"]
CMD ["https://en.wikipedia.org/wiki/Cat"]

2.2 Building an image

We’re now going to build an image from a Dockerfile.

1. Create a new file named Dockerfile under the folder myfigures.

2. In the Dockerfile write the set of instructions that you proposed in Exercise 2.2.

3. In the terminal, set the working directory to myfigures.

4. Build an image called dlimages by executing the following command:

docker build -t dlimages .

The . at the end of the command means that the Docker engine will look for a file named Dockerfile in the working directory.

In order to verify that the new image has been created, type the following command:

docker images

docker cp dl1:/downloads .

docker run --name dl2 dlimages https://en.wikipedia.org/wiki/Dog

2.3 Containerized Python application

Download this archive file and unzip it into your working directory. In this archive you’ll find:

• A Dockerfile.
• A Python script main.py that asks the user to enter the URL and the language of a Web page, and prints the 10 most frequent words occurring in that page.
• A file requirements.txt with the list of the Python packages needed to run the given script.

The content of the Dockerfile is as follows:

FROM python:3.7-slim
RUN mkdir -p /app
WORKDIR /app
COPY ./main.py ./requirements.txt /app/
RUN pip install -r requirements.txt
ENTRYPOINT ["python", "main.py"]

print("Finish!")

FROM python:3.7-slim
RUN mkdir -p /app
WORKDIR /app
COPY ./requirements.txt /app/
RUN pip install -r requirements.txt
COPY ./main.py /app/
ENTRYPOINT ["python", "main.py"]

Play with the application by running the following command:

docker run --rm -it wordfreq

The containerized application will prompt you to insert the URL of a webpage and the language of the page (in English). The output will be the 20 most used words in the webpage.

3.1 Docker volumes

A volume can be seen as a virtual storage device attached to a container. All files there are written to a volume survive the containerized application that created them. In other words, when a container is destroyed, all the files created by the application in the container remain in the volume.

Let’s create a new Docker volume called data-volume:

docker volume create data-volume

4.1 Creating networks

By default, any new container is attached to the network named bridge.

In order to create a new network, you can use the following command:

docker network create network_name

4.2 Communication between containers

Let’s see if and when the three containers can communicate.

You can now exit the three containers.