Docker command/option to display or list the build context

Question

Is there a command/option to display or list the context which is sent to the Docker daemon for building an image?

$ docker build -t "image-name"
Sending build context to Docker daemon 8.499 MB
...

Files and directories can be excluded from the build context by specifying patterns in a .dockerignore file. I guess what I'm looking for amounts to testing the .dockerignore in addition to any other niche rules Docker uses when determined the context.

score 78 · Answer 1 · answered May 30 '19 at 07:32

78

Answers above are great, but there is a low-tech solution for most cases - ncdu. This utility will show pretty and interactive tree structure with sizes. It has an option that will take patterns from a file and exclude them from scan. So you can just do ncdu -X .dockerignore. You will get something like this:

This is pretty close to what you will get in your docker image. One caveat is thou if you add a dot directory (like .yarn) into an image, it will not show in ncdu output.

answered May 30 '19 at 07:32

RawCode

1,073
8
13

1

:) I was looking for exactly this. This is an excellent answer. `ncdu` is something that was preinstalled. – Utsav Chokshi Jun 03 '19 at 20:40
2

A useful tool indeed, but it doesn't respect `.dockerignore`, which might be relevant given the question. – MatrixManAtYrService Sep 20 '19 at 21:49
@MatrixManAtYrService You can tell it to use ignore file using `ncdu -X .dockerignore` – RawCode Sep 24 '19 at 06:27
My mistake, I should have read more closely. That's a neat trick! – MatrixManAtYrService Sep 25 '19 at 23:44
10

It looks like the `-X` option doesn't support whitelist rules in `.dockerignore` – bartolo-otrit Nov 12 '19 at 11:23
3

I don't see it respecting the blacklist items either (at least on the ncdu installed today from Homebrew). – Keegan Feb 24 '20 at 19:19
5

This is not a good answer: `ncdu`'s `-X` option does not follow the docker's `.dockerignore` file syntax and specification – kaznovac Mar 07 '21 at 19:46
If the `.dockerignore` entries start with a slash, it won't work. – jlh Dec 10 '22 at 14:29

Ricardo Branco · Accepted Answer · 2019-02-18T09:59:13.720

65

The only way would be to add the current directory to an specific directory and list it.

Try building with this Dockerfile:

FROM busybox

RUN mkdir /tmp/build/
# Add context to /tmp/build/
COPY . /tmp/build/

Build it with:

docker build -t test .

List all the files and directories in /tmp/build:

docker run --rm -it test find /tmp/build

edited Feb 18 '19 at 09:59

answered May 05 '17 at 17:06

Ricardo Branco

5,740
1
21
31

25

You could do it in one step by including `RUN find /tmp/build` in the Dockerfile. – tlrobinson Jan 21 '19 at 20:59
Sorry, I don't know about Windows but WSL should have these GNU utilities installed. – Ricardo Branco Jun 03 '20 at 09:35
1

You no longer need `RUN mkdir` – jchook Mar 17 '22 at 02:32
grabbing the one-liners approach from @whitone, but adapting to use the commands from this answer, for when buildx isn't available, we get: `printf 'FROM busybox\nCOPY . /tmp/build/\nRUN find /tmp/build' | docker build -f- .` – Tom Saleeba Jul 19 '23 at 07:26
...or if you want to see the size of the directories to help focus your search for large objects, you can use `printf 'FROM busybox\nCOPY . /tmp/build/\nRUN du -xhd1 /tmp/build' | docker build -f- .` (`du -xhd1` is the difference) – Tom Saleeba Jul 19 '23 at 07:31

score 33 · Answer 3 · answered May 15 '20 at 14:37

Starting with version 18.09, Docker has an option to export context data using BuildKit backend.

It's not enabled by default, so you need to set an environment variable DOCKER_BUILDKIT=1 before invoking docker build command.

The following command can work also if you don't have any Dockerfile in current directory.

printf 'FROM scratch\nCOPY . /' | DOCKER_BUILDKIT=1 docker build -f- -o context .

When you run multiple times remember to delete previous export with rm -r context.

You can also get context data as archive and then mount with archivemount command:

printf 'FROM scratch\nCOPY . /' | DOCKER_BUILDKIT=1 docker build -f- -o- . > context.tar
mkdir context
archivemount context.tar context

With both methods, then you can explore the result with ncdu context.

nice, great answer ️(for people not wanting to install ncdu: `du -m context | sort -n`) ‍♂️️ — Herbert Poul, Jun 26 '20 at 09:35
Instead of redirecting to `context.tar` you also can just pipe the output to `tar -tv` so you don't have to deal with temporary files and directories. — David Ongaro, Aug 15 '20 at 01:32

score 13 · Answer 4 · answered Feb 16 '19 at 08:15

Updated answer: Since 2017, Docker has recommended to use COPY instead of ADD and with the comment from @tlrobinson, the simpler Dockerfile looks like so:

# debug and list the docker build context so that you can minimmize it
#
# usage:
#  docker build -f docker/context.Dockerfile -t test/buildcontext .
#
######################
FROM busybox

RUN mkdir /tmp/build/
# Add context to /tmp/build/
COPY . /tmp/build

# this last command outputs the list of files added to the build context:
RUN find /tmp/build/

I updated my answer to use `COPY` but the `find` in `RUN` doesn't have the flexibility of using the `find` command line options unless one uses ENTRYPOINT. — Ricardo Branco, Feb 18 '19 at 10:00

score 1 · Answer 5 · answered Mar 24 '22 at 15:35

1

What worked for me is to do the following (based on this article).

Tell Docker to use the old build kit. In PowerShell that is:

$ENV:DOCKER_BUILDKIT=0
Run Docker build so that it reports ALL the progress it's making:

docker build --progress=plain BLAH

Given those two things you can then do something as simple as this in your Docker file:

RUN ls /app

And that will give you a list out of everything in the /app folder.

answered Mar 24 '22 at 15:35

Louis Cribbins

121
1
2

`RUN ls -R` is a better option, it's recursive, also run `docker build --no-cache` whilst tweaking your .gitignore file. – alv Jan 18 '23 at 12:30

score 1 · Answer 6 · answered Jan 26 '23 at 10:43

Here is a script that outputs the context tarball sent by docker build to the Docker daemon. You can examine it like /path/to/script_below | tar -tv for example.

#!/usr/bin/python3

from http.server import BaseHTTPRequestHandler
from re import match
from socketserver import UnixStreamServer
from subprocess import Popen, DEVNULL
from sys import exit, stdout
from tempfile import TemporaryDirectory

class ContextDumper(BaseHTTPRequestHandler):
    def __init__(self, request, client_address, server):
        # provide dummy client address for error reporting
        super().__init__(request, ('docker_context', 0), server)
        
    def do_HEAD(self):
        if self.path != '/_ping':
            self.send_error(404, '/_ping only')

    do_GET = do_HEAD

    def do_POST(self):
        if match(r'/v1\.\d+/build\?', self.path) is None:
            self.send_error(404, '/v1.X/build only')
            exit(1)
        total = 0
        while True:
            chunk_length = int(self.rfile.readline().strip(), 16)
            total += chunk_length
            chunk = self.rfile.read(chunk_length)
            stdout.buffer.write(chunk)
            self.rfile.readline()
            if chunk_length == 0:
                break
        padding = (512 - (total % 512)) % 512
        stdout.buffer.write(bytes(padding))
        exit(0)

with TemporaryDirectory() as tmpdir:
    socket_path = tmpdir + '/docker_context.sock'
    fake_dockerd = UnixStreamServer(socket_path, ContextDumper)
    with Popen(['docker', f'--host=unix://{socket_path}', 'build', '--file=/dev/null', '.'],
               stdout=DEVNULL, stderr=DEVNULL) as builder:
        fake_dockerd.serve_forever()

Docker command/option to display or list the build context

6 Answers6