A Deep Dive into Container Images - Part 3

In the previous article we discussed how to create a Docker image the best way for languages considered static, like C or Go. In this article we will explore a bit more about creating images using dynamic languages, like Python or JavaScript.

Goodbye Scratch Images#

As we discussed in the first article, we have a type of image called scratch, which is a completely empty image, really just an empty filesystem. We used this type of image to build our container in the previous article.

However, the bad news is that we cannot use this type of image to create our dynamic containers, because we need the language runtime installed in the operating system, so we will only be using full, slim, and alpine images.

Multi-stage Builds#

Just like we did in the previous article, it is possible to take advantage of a multi-stage build process, that is, we have a container that contains all the resources and development tools to build our application, but we don’t use this container for production, instead we use another container that will contain the minimum possible.

This also applies to dynamic languages, but we have some modifications we need to make for these builds to be more efficient. Since we won’t have a single binary to copy, the ideal would be to copy the entire directory. Some languages like Python have a good relationship with this type of build because this language has VirtualEnv, which allows us to logically separate the environments we are working in.

We will do this test with a simple application, a JavaScript API that sends emails, the source code can be seen here. To start, let’s analyze the Dockerfile with the build image:

1
FROM node:12 AS builder
2

3
RUN mkdir -p /usr/src/app
4
WORKDIR /usr/src/app
5

6
## Install dependencies
7
COPY ["./package.json", "./package-lock.json", "/usr/src/app/"]
8

9
RUN npm install
10

11
## Add source code
12
COPY ["./tsconfig.json", "/usr/src/app/"]
13
COPY "./src" "/usr/src/app/src/"
14

15
## Build
16
RUN npm run build

The Node:12 image may vary in space used, but the raw image has about 340Mb. As you can see, base images for dynamic languages are much larger than images for compiled languages because we need the runtime to be included.

However, we will make a change since full images can have many vulnerabilities, we will switch to the slim image which has approximately 40mb

1
FROM node:12-slim AS builder
2

3
RUN mkdir -p /usr/src/app
4
WORKDIR /usr/src/app
5

6
## Install dependencies
7
COPY ["./package.json", "./package-lock.json", "/usr/src/app/"]
8

9
RUN npm install
10

11
## Add source code
12
COPY ["./tsconfig.json", "/usr/src/app/"]
13
COPY "./src" "/usr/src/app/src/"
14

15
## Build
16
RUN npm run build

We can make it even better if we change our image to an alpine image!

1
FROM node:12-alpine AS builder
2

3
RUN mkdir -p /usr/src/app
4
WORKDIR /usr/src/app
5

6
## Install dependencies
7
COPY ["./package.json", "./package-lock.json", "/usr/src/app/"]
8

9
RUN npm install
10

11
## Add source code
12
COPY ["./tsconfig.json", "/usr/src/app/"]
13
COPY "./src" "/usr/src/app/src/"
14

15
## Build
16
RUN npm run build

Now the build image has only 28mb initially to be downloaded.

Production Image#

We have already created our builder, now let’s create our production image. For this, we will use the alpine image which is much smaller!

1
# PRODUCTION IMAGE
2

3
FROM node:12-alpine
4

5
RUN mkdir -p /usr/app
6
WORKDIR /usr/app
7

8
COPY --from=builder [\
9
  "/usr/src/app/package.json", \
10
  "/usr/src/app/package-lock.json", \
11
  "/usr/app/" \
12
  ]
13

14
COPY --from=builder "/usr/src/app/dist" "/usr/app/dist"
15
COPY ["./scripts/install_renderers.sh", "/usr/app/scripts/"]
16

17
RUN npm install --only=prod
18

19
EXPOSE 3000
20

21
ENTRYPOINT [ "npm", "start" ]

We are copying only the TypeScript output folder into our production image and we are only installing the dependencies needed for a production application with npm install --only=prod.

In the same way we are exposing the necessary ports and creating the startup script only in this image and not in the build image, since it will not be used.

Putting them all together we have:

1
FROM node:12-slim AS builder
2

3
RUN mkdir -p /usr/src/app
4
WORKDIR /usr/src/app
5

6
## Install dependencies
7
COPY ["./package.json", "./package-lock.json", "/usr/src/app/"]
8

9
RUN npm install
10

11
## Add source code
12
COPY ["./tsconfig.json", "/usr/src/app/"]
13
COPY "./src" "/usr/src/app/src/"
14

15
## Build
16
RUN npm run build
17

18
# PRODUCTION IMAGE
19

20
FROM node:12-alpine
21

22
RUN mkdir -p /usr/app
23
WORKDIR /usr/app
24

25
COPY --from=builder [\
26
  "/usr/src/app/package.json", \
27
  "/usr/src/app/package-lock.json", \
28
  "/usr/app/" \
29
  ]
30

31
COPY --from=builder "/usr/src/app/dist" "/usr/app/dist"
32
COPY ["./scripts/install_renderers.sh", "/usr/app/scripts/"]
33

34
RUN npm install --only=prod
35

36
EXPOSE 3000
37

38
ENTRYPOINT [ "npm", "start" ]

The final image has approximately 120mb, but the alpine Node image is 28Mb, that is, we have approximately 90mb of applications and dependencies in this image. If we were using a full image, this size would easily be larger than 1gb.

Conclusion#

Knowing how to create your images is an important skill, because with it we can reduce the size and transform our application into something much more concise and lightweight that makes downloading and using our images much easier.

Don’t forget to subscribe to the newsletter for more exclusive content and weekly news! Like and share your feedback in the comments!

See you!