Content Introduction Prerequisites Virtual Host Redirect to HTTPS Conclusion Introduction To secure the data transfer redirecting the HTTP traffic to...
Read More
Introduction
In this tutorial, we recommended methods and best practices for building efficient images.
The Docker builds images automatically by following or reading the instructions from a Dockerfile (here, Dockerfile is a text file that store or contains all the commands, in order, that are needed/required to build a given image).
Dockerfile stick to a specific format and set of instructions. A Docker image consists of read-only layers each of which reflects a Dockerfile instruction. The layers are stacked and each layer is a delta of the changes from the previous layer.
Dockerfile Sample
The sample Dockerfile is shown as below:
FROM ubuntu:18.04
COPY . /app
RUN make /app
CMD python /app/app.py
Each and every instruction creates a layer:
- FROM, it creates a layer from the Docker image (ubuntu:18.04).
- COPY, it adds files from the current directory of your Docker client’s.
- RUN, it builds your application with make.
- CMD, it specifies what command should be run inside the container.
When the image runs and generates a new container, it adds a new writable layer (known as the “container layer”) on top of the underlying layers. All the changes made to the running container, such as modifying existing files, deleting files, and writing new files are written to this thin writable container layer.
Guidelines and Recommendations
- Create ephemeral containers – The Dockerfile should define images and generate containers in such a way that it will be as ephemeral as possible. Here, “ephemeral” means that the containers can be destroyed and can be stopped, then rebuilt and replaced with a very minimum set up and configuration.
- Understand build context – The build context means, the current working directory from where you execute the docker build command and the dockerfile is located in this directory by default (which you can change also using the file flag “-f”).
Also, all the recursive contents of directories and files of the current directory are sent to the Docker daemon as the build context.
- Pipe Dockerfile through stdin – Docker uses piping inside Dockerfile to build images through stdin with a remote or local build context. Piping a dockerfile is useful to perform the one-off builds without writing the file to disk.
- Exclude with .dockerignore – Use a .dockerignore file to exclude files that are not relevant to the build without restructing your source repo, this file supports some patterns similar to the .gitignore files.
- Don’t install unnecessary packages – To reduce file sizes, dependencies, build times and complexity avoid installing extra or unnecessary packages just because they might be nice to have.
- Minimize the number of layers – In Docker’s old versions, it was important that you minimized the number of layers in your images to ensure they were performant.
Instructions for Docker
LABEL
To organize the images by project, you can add labels to your image.
Add a line beginning with LABEL for each label and with one more key-value pairs.
Strings with spaces are quoted or the spaces are escaped. Inner quote characters (“), must also be escaped.
# Set one or more individual labels
LABEL com.example.version="0.0.1-beta"
LABEL vendor1="ACME Incorporated"
LABEL vendor2=ZENITH\ Incorporated
LABEL com.example.release-date="2015-02-12"
LABEL com.example.version.is-production=""
RUN
Split the complex and long RUN statements which are separated on multiple lines with the backslashes for making your Dockerfile more maintainable, understandable, and readable.
APT-GET
It is the most common use-case for RUN in an application of apt-get.
This installs packages. Always combine RUN apt-get update with apt-get install in the same RUN statement.
Example:
RUN apt-get update && apt-get install -y \
package-bar \
package-baz \
package-foo \
&& rm -rf /var/lib/apt/lists/*
COPY requirements.txt /tmp/
RUN pip install --requirement /tmp/requirements.txt
COPY . /tmp/
ADD https://example.com/big.tar.xz /usr/src/things/
RUN tar -xJf /usr/src/things/big.tar.xz -C /usr/src/things
RUN make -C /usr/src/things all
Examples for Official Images
Below are some Official Images which have exemplary Dockerfiles:
- Ruby
- Perl
- Go
- Hy
Related Posts
How to Build and Deploy Angular Code to S3 Bucket using GitHub Actions
Content Introduction Requirement Getting Started Conclusion Introduction Angular is an open-source web application framework. It is a TypeScript-based free and development...
Read More
by Zehntech