Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Building Images Using Dockerfiles

5:31 with Jay McGavren and Jared Smith

Developers use configuration files to customize the tools they use every day. Likewise, Docker looks for a Dockerfile for instructions on how it should build an image. In this stage, we're going to learn about all the instructions you can include in a Dockerfile so that your image is configured just the way you want it.

Teacher's Notes
Video Transcript
Downloads

Here are the contents of the files used in the video:

Dockerfile

# Base Image
FROM ubuntu:latest

# Commands to run to install dependencies
RUN apt-get update -y
RUN apt-get install -y python3

# When you pass commands to the container, what should interpret them
ENTRYPOINT ["python3"]

# Command to run when the container starts
CMD ["app.py"]

# Working directory
WORKDIR /app

# Copy apps from the local folder to the Docker container
COPY app.py app.py
COPY alternate.py alternate.py

# Make port available
EXPOSE 8080

app.py

#!/usr/bin/env python

from http.server import BaseHTTPRequestHandler, HTTPServer

class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type','text/html')
        self.end_headers()
        self.wfile.write(bytes("Hello from Python!", "utf8"))
        return

def run():
    httpd = HTTPServer(('0.0.0.0', 8080), testHTTPServer_RequestHandler)
    httpd.serve_forever()

run()

alternate.py

#!/usr/bin/env python

from http.server import BaseHTTPRequestHandler, HTTPServer

class testHTTPServer_RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type','text/html')
        self.end_headers()
        self.wfile.write(bytes("This is an alternate app!", "utf8"))
        return

def run():
    httpd = HTTPServer(('0.0.0.0', 8080), testHTTPServer_RequestHandler)
    httpd.serve_forever()

run()

Further Reading

0:04
Developers use configuration files to customize the tools they use everyday.
0:09
For example, shells look for
0:10
config files so they know what prompt to display for you.
0:13
What functions to load and so on.
0:16
Programming languages have tools that use configuration files to build an app.
0:20
Likewise, Docker looks for a dockerfile for
0:23
instructions on how it should build an image.
0:26
In this stage, we're going to learn about all the instructions you can include in
0:29
a dockerfile, so that your image is configured just the way you want it.
0:35
A dockerfile is just a plain text file that you store in your application
0:39
directory.
0:40
Dockerfiles let you install application dependencies within the image,
0:44
specify how to run your app, set up networking configuration, and much more.
0:49
When you use the docker command-line interface to build an image,
0:52
it will look for
0:53
your dockerfile, and use the instructions it contains to set up your image.
0:58
Lines of a dockerfile are either comments or instructions.
1:01
If a line has a pound or hash symbol at the very beginning and
1:05
only at the very beginning, it's treated as a comment line and ignored by docker.
1:10
All other lines are treated as instructions.
1:13
An instruction is several of predefined key words followed by one or
1:17
more arguments.
1:19
By convention, an instruction key word should be in all caps,
1:22
although Docker itself doesn't require that.
1:25
You remember the image for our Python web app that we created earlier in the course.
1:29
We installed Python, copied a script from the host file system into the images file
1:34
system, and then set it up to run that script when the container launched.
1:38
Here's the dockerfile that we used to create that image.
1:41
If you want a copy, see the teacher's notes.
1:44
This file illustrates several important commands,
1:47
which we'll go over in the next few videos.
1:49
You can see FROM, RUN, ENTRYPOINT, CMD,
1:53
WORKDIR, COPY, and EXPOSE instructions here.
1:59
To build an image based on this dockerfile,
2:01
we need to run the docker build command from our terminal.
2:05
We need to supply a repository name and tag for
2:08
the image, which we'll do with the -t option.
2:11
We'll use a repository name of sample-web-app.
2:17
Then we need to type a colon character followed by the tag we want to apply.
2:21
We'll use a tag of 1.0.
2:23
Lastly we need to specify the directory that contains our dockerfile.
2:27
Since this is a Python web app I have it stored in the directory called Python.
2:33
If we run this we'll see docker carrying out the instructions in our dockerfile
2:37
one by one.
2:39
It retrieves a copy of the Ubuntu image which our image is going to be based on.
2:43
It runs commands to install Python 3 and
2:46
copies our app source code over from the Python directory to the image.
2:50
It sets our app up to run when the container starts and
2:54
it exposes network port 8080 which our app will be listening for connection on.
2:59
Now that we've created an image, we can run it using the docker run command.
3:05
This image exposes a port.
3:07
But we'll need to publish that port before anyone can connect to it.
3:11
We'll publish the exposed port 8080 to port 8080 on the host,
3:18
with the -p option, -p 8080:8080.
3:23
Then we need to specify the image name and tag we want to run.
3:26
We'll use the same name and tag we specified when
3:31
running docker build, sample-web-app:1.0.
3:35
When we hit enter, the container will run.
3:38
If we make a connection to port 8080, on our dot host with localhost:8080,
3:46
it will be forwarded to the exposed port 8080 on our container.
3:52
We should get a response from our app, which is running within the container.
3:56
Our terminal is still attached to the web app running on the container.
4:00
So we can just go back to our terminal and press Ctrl + C to shut it down.
4:04
Since our web app is the container's main process
4:07
the container will shut down as soon as the app does.
4:10
Before we move on I want to show you a couple possible variations of
4:14
the command to build and tag images.
4:16
Often, you'll be building an image when you're already in the same
4:19
directory that contains your dockerfile.
4:22
If we were to change to the Python directory and
4:25
list files, our dockerfile would be there.
4:28
If this is the case,
4:29
you can just specify the current directory as the one that contains your dockerfile.
4:34
So let's build up the docker build command again and
4:38
edit it to work within the current directory.
4:41
The only thing we need to change is the directory name,
4:44
which we just changed to a single dot, which specifies the current directory.
4:50
You also don't have to specify a particular tag when you're just
4:53
experimenting with different builds.
4:55
When you're running docker build and you need a value to pass for
4:58
the -t option, you can specify just the repository name.
5:02
So in this case, that would be sample-web-app.
5:04
And you can leave the tag portion following the colon off.
5:07
By default, Docker will use a tag of latest.
5:11
The same is true when running a container with docker run.
5:16
You'll still need to specify any ports you want to publish, but
5:18
you can just specify the repository name and leave the tag off.
5:23
Docker will use a default of latest.
5:26
In the next few videos we'll take a look at the instructions used in our
5:30
dockerfile.
5:31
See you there.

You need to sign up for Treehouse in order to download course files.

Sign up