Ajshen at 03:35, 29 June 2026

2026-06-29T03:35:53Z

← Older revision		Revision as of 03:35, 29 June 2026
Line 1:		Line 1:

			[[Category:Containers and Virtual Environments]]

	This tutorial is supposed to serve as a simple self-contained example that shows how to build a Docker image for a project that might be of interest in our department: a simple application using PyTorch.		This tutorial is supposed to serve as a simple self-contained example that shows how to build a Docker image for a project that might be of interest in our department: a simple application using PyTorch.

Skipper at 02:19, 24 May 2024

2024-05-24T02:19:16Z

← Older revision		Revision as of 02:19, 24 May 2024
Line 67:		Line 67:
	If everything went well, you should see something like this:		If everything went well, you should see something like this:

	'''<code>[[File:Docker build.png\|900x500px\|RTENOTITLE]]</code>'''		'''<code>[[File:1704px-Docker build.png\|900x500px\|RTENOTITLE]]</code>'''

Skipper: Created page with " This tutorial is supposed to serve as a simple self-contained example that shows how to build a Docker image for a project that might be of interest in our department: a..."

2024-03-29T23:52:36Z

Created page with " This tutorial is supposed to serve as a simple self-contained example that shows how to build a Docker image for a project that might be of interest in our department: a..."

New page

This tutorial is supposed to serve as a simple self-contained example that shows how to build a Docker image for a project that might be of interest in our department: a simple application using PyTorch.

To complete this tutorial, we will rely on [[Python_virtual_environments|conda]] Python version 3.8 or later. You also need to have installed Docker (see [https://docs.docker.com/desktop/ download and install Docker]).

== Example application ==

Create a directory named <code>docker </code>and create a conda environment with Python and PyTorch installed in it. Don't forget to activate the environment before installing packages!

Then, create a <code>test_docker.py </code>file and add the following simple lines:
<pre>import torch

a = torch.Tensor([1, 2, 3, 4, 5])

if __name__ == '__main__':
print(a)
</pre>

= Inherit from an existing image =

== Create a Dockerfile for Python ==

Inside the <code>docker </code>directory create a <code>Dockerfile</code> (simply by tipying <code>touch Dockerfile</code>) and add a line that tells Docker <u>what base image to use</u> for the application.
<pre># syntax=docker/dockerfile:1

FROM python:3.8-slim-buster</pre>

Docker images can inherit from other images. Therefore, instead of creating your own base image, you can use the official Python image that has all the tools and packages needed to run a Python application.

To make things easier when running the remaining commands, create a <u>working directory</u>. This instructs Docker to use this path as the default location for all subsequent commands. This means you can use relative file paths based on the working directory instead of full file paths.
<pre>WORKDIR /path/to/your/project/dir
</pre>

Now we would like the Docker image to install all the necessary packages we have in the environment. When installing Python, conda automatically downloads the <code>pip </code>package manager as well. We can then use it to create a requirements file by typing
<pre>pip list --format=freeze > requirements.txt</pre>

in the terminal, within the <code>docker</code> directory. Then we need to make sure the requirements file will be in the image. The <code>COPY</code> command takes two parameters. The first parameter tells Docker what file(s) you would like to copy into the image. The second parameter tells Docker where to copy that file(s) to. For this example, copy the <code>requirements.txt</code> file into the working directory:
<pre>COPY requirements.txt requirements.txt
</pre>

With the <code>requirements.txt</code> file inside the image, you can use the <code>RUN</code> command to run <code>pip install</code>. This works exactly the same as running <code>pip install</code> locally on a machine, but this time pip installs the modules into the image.
<pre>RUN pip install -r requirements.txt
</pre>

At this point, you have an image based on Python version 3.8 and have installed the dependencies. The next step is to add the source code into the image. Use the <code>COPY</code> command as with the <code>requirements.txt</code> file. 
<pre>COPY test_docker.py test_docker.py</pre>

Now, tell Docker what command to run when the image is executed inside a container using the <code>CMD</code> command.
<pre>CMD ["python", "test_docker.py"]</pre>

The complete<code> Dockerfile </code>should look like this:
<pre># syntax=docker/dockerfile:1
FROM python:3.8-slim-buster
WORKDIR /path/to/your/project/dir
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY test_docker.py test_docker.py
CMD ["python", "test_docker.py"]
</pre>

== Build an image ==

Now that you’ve created the Dockerfile, let’s build the image. To do this, use the <code>docker build</code> command. The <code>docker build</code> command builds Docker images from a Dockerfile and a “context”. A build’s context is the set of files located in the specified PATH or URL. The Docker build process can access any of the files located in this context.

The build command optionally takes a <code>--tag</code> flag. The tag sets the name of the image and an optional tag in the format <code>name:tag. </code>Don't forget to open the Docker Desktop application before running the build command, otherwise the Docker deamon will not be running and the command will not work.

If everything went well, you should see something like this:

'''<code>[[File:Docker build.png|900x500px|RTENOTITLE]]</code>'''

== Run the image ==

Now that we have an image, we can run that image and see if our application is running correctly.

A container is a normal operating system process except that this process is isolated in that it has its own file system, its own networking, and its own isolated process tree separate from the host.

To run an image inside of a container, we use the <code>docker run</code> command. The <code>docker run</code> command requires one parameter which is the name of the image. Let’s start our image and make sure it is running correctly. Run the following command in your terminal.
<pre>docker run test-docker</pre>

If everything goes well, you should see the desired output printed in the terminal (in this case, a simple PyTorch Tensor).

= Creating new base images =

Most Dockerfiles start from a parent image. If you need to completely control the contents of your image, you might need to create a base image instead. Here’s the difference:

*A [https://docs.docker.com/glossary/#parent-image parent image] is the image that your image is based on. It refers to the contents of the <code>FROM</code> directive in the Dockerfile. Each subsequent declaration in the Dockerfile modifies this parent image. Most Dockerfiles start from a parent image, rather than a base image. However, the terms are sometimes used interchangeably.
*A [https://docs.docker.com/glossary/#base-image base image] has <code>FROM scratch</code> in its Dockerfile.

See this [https://docs.docker.com/build/building/base-images/ link] for details.

Tutorials - Revision history

Ajshen at 03:35, 29 June 2026

Skipper at 02:19, 24 May 2024

Skipper: Created page with " This tutorial is supposed to serve as a simple self-contained example that shows how to build a Docker image for a project that might be of interest in our department: a..."