9

To my knowledge of the way docker build works is that for each line of instruction, it creates a separate image/layer. However, it is very efficient in managing to reuse the layers or avoid rebuilding those layers if nothing has changed.

So does it matter if I put below instruction either on same line or multi-line? For convenience, I would prefer the single line option unless it is not an efficient option.

Multi-Line Instruction

RUN apt-get -y update
RUN apt-get -y install ...

Single-Line Instruction

RUN apt-get -y update && apt-get -y install
Sagar Shroff
  • 105
  • 1
  • 5
  • 4
    Does this answer your question? [Multiple RUN vs. single chained RUN in Dockerfile, what is better?](https://stackoverflow.com/questions/39223249/multiple-run-vs-single-chained-run-in-dockerfile-what-is-better) – Kapil Khandelwal Apr 26 '20 at 11:00

2 Answers2

13

In this specific case it is important to put apt-get update and apt-get install together. More broadly, fewer layers is considered "better" but it almost never has a perceptible difference.

In practice I tend to group together "related" commands into the same RUN command. If I need to configure and install a package from source, that can get grouped together, and even if I change make arguments I don't mind re-running configure. If I need to configure and install three packages, they'd go into separate RUN lines.

The important difference in this specific apt-get example is around layer caching. Let's say your Dockerfile has

FROM ubuntu:18.04
RUN apt-get update
RUN apt-get install package-a

If you run docker build a second time, it will decide it's already run all three of these commands and the input hasn't changed, so it will run very quickly and you'll get an identical image out.

Now you come back a day or two later and realize you were missing something, so you change

FROM ubuntu:18.04
RUN apt-get update
RUN apt-get install package-a package-b

When you run docker build again, Docker decides it's already run apt-get update and can jump straight to the apt-get install line. In this specific case you'll have trouble: Debian and Ubuntu update their repositories fairly frequently, and when they do the old versions of packages get deleted. So your apt-get update from two days ago points at a package that no longer exists, and your build will fail.

You'll avoid this specific problem by always putting the two apt-get commands together in the same docker run line

FROM ubuntu:18.04
RUN apt-get update \
 && DEBIAN_FRONTEND=noninteractive \
    apt-get install --assume-yes --no-install-recommends \
      package-a \
      package-b
David Maze
  • 130,717
  • 29
  • 175
  • 215
  • How is putting both apt-get commands into a single RUN command avoids this specific problem? Doesn't Docker decide that it ran the command before, also in this case? What makes it re-run the RUN operation, the apt-get install command? – Hmerac Jul 27 '21 at 11:25
  • If Docker sees the text of a `RUN` line changes, it re-runs the entire line. If `apt-get update` and `apt-get install` are on separate lines, but the `update` hasn't changed, the `install` will run on an old version of the package index (and possibly fail). But if they're on the same line, it forces Docker to run `update` and `install` together, and you'll always be using a current version of the package index. – David Maze Jul 27 '21 at 11:52
4

I would use single-line instruction. It's considered to be a best practice for docker. So that you minimize number of layers(RUN is one of instructions that create layers).

As of multiple instructions for collecting dependencies, sometimes it's useful during development, if you're frequently changing list of packages(or their versions). But for production image, i would avoid that.

Grigoriy Mikhalkin
  • 5,035
  • 1
  • 18
  • 36