{"id":7735,"date":"2018-10-03T08:05:29","date_gmt":"2018-10-03T00:05:29","guid":{"rendered":"http:\/\/rmohan.com\/?p=7735"},"modified":"2018-10-03T08:05:58","modified_gmt":"2018-10-03T00:05:58","slug":"copy-and-add-commands-in-dockerfile","status":"publish","type":"post","link":"https:\/\/mohan.sg\/?p=7735","title":{"rendered":"COPY and ADD commands in Dockerfile"},"content":{"rendered":"

COPY and ADD commands in Dockerfile<\/strong><\/p>\n

Two very similar commands COPY and ADD are provided in the Dockerfile. This article attempts to explain the basic functions of these two commands, as well as their similarities and differences, and then summarize their respective suitable application scenarios.<\/p>\n

Build context concept
\nWhen you create a mirror from a Dockerfile using the docker build command, a build context is generated. The so-called build context is the collection of files in the path specified by the PATH or URL of the docker build command. Any file in the context can be referenced during the image build process, such as the COPY and ADD commands we will introduce, to reference the files in the context.<\/p>\n

By default, the docker build -t testx . command in the command indicates that the build context is the current directory. Of course we can specify a directory as the context, such as the following command:<\/p>\n

$ docker build -t testx \/home\/mohan\/hc<\/p>\n

We specify the \/home\/mohan\/hc directory as the build context. By default, docker will use the Dockerfile found in the root of the context.<\/p>\n

The COPY and ADD commands cannot copy local files outside the context.
\nFor COPY and ADD commands, if you want to copy a local file to an image, the local file must be a file in the context directory.
\nIn fact, this is a good explanation, because when the build command is executed, the docker client will send all the files in the context to the docker daemon . Considering that the docker client and the docker daemon are not on the same machine,<\/p>\n

the build command can only get the file from the context. If we reference a file that is not in the context in the COPY and ADD commands of the Dockerfile, we receive an error similar to the following:<\/p>\n

Work with WORKDIR<\/p>\n

The WORKDIR command configures the working directory for subsequent commands such as RUN, CMD, COPY, and ADD. After the WORKDIR command is set, the relative path in the next COPY and ADD commands is the path specified relative to WORKDIR. For example, we add the following command to the Dockerfile:<\/p>\n

WORKDIR \/app
\nCOPY checkredis.py .<\/p>\n

Then build a container image named testx and run a container to view the file path:<\/p>\n

The checkredis.py file is copied to the WORKDIR \/app directory.<\/p>\n

The simplicity of the COPY command
\nIf you just copy the local file to the container image, the COPY command is the most appropriate. The format of the command is:
\nCOPY <src> <dest><\/p>\n

In addition to specifying the full file name, the COPY command also supports Go-style wildcards, such as:<\/p>\n

COPY check* \/testdir\/ # Copy all files at the beginning of
\ncheck COPY check?.log \/testdir\/ # ? is a placeholder for a single character, such as matching file check1.log<\/p>\n

For directories, the COPY and ADD commands have the same characteristics: only copy the contents of the directory and not the directory itself. For example, we add the following command to the Dockerfile:<\/p>\n

WORKDIR \/app
\nCOPY mohandir .<\/p>\n

The structure of the mohandir directory is as follows:<\/p>\n

There are only file1 and file2, and there is one less directory mohandir. If you want file1 and file2 to be saved in the mohandir directory, you need to specify the name of the directory in the target path, for example:<\/p>\n

WORKDIR \/app
\nCOPY mohandir .\/mohandir<\/p>\n

One use of the COPY command from the ADD command is in a multistage scenario. For an introduction and usage of multistage, please refer to the author’s article ” multi-stage in Dockerfile “. In the multistage usage, you can use the COPY command to copy the product from the previous stage to another image, such as:<\/p>\n

FROM golang: 1.7.3
\nWORKDIR \/go\/src\/github.com\/sparkdevo\/href-counter\/
\nRUN go get -d -v golang.org\/x\/net\/html
\nCOPY app.go .
\nRUN CGO_ENABLED=0 GOOS=linux Go build -a -installsuffix cgo -o app .<\/p>\n

FROM alpine:latest
\nRUN apk –no-cache add ca-certificates
\nWORKDIR \/root\/
\nCOPY –from=0 \/go\/src\/github.com\/sparkdevo\/href-counter\/app .
\nCMD [“.\/app”]<\/p>\n

This code is referenced in the article ” multi-stage in Dockerfile “, where the COPY command copies the product of the previous stage build into the current image by specifying the –from=0 parameter.<\/p>\n

The ADD command can also do other things.
\nThe format of the ADD command is the same as the COPY command, which is also:
\nADD <src> <dest><\/p>\n

In addition to the fact that it can’t be used in multistage scenarios, the ADD command can do all the functions of the COPY command, and it can also do two cool features:<\/p>\n

Extract the compressed files and add them to the image
\nCopy files from url to image
\nOf course, these features also make the ADD command more complicated and less intuitive than the COPY command.<\/p>\n

Extract the compressed files and add them to the image.
\nIf we have a compressed file package, we need to add the files from this compressed package to the image. Do you need to unpack the package and then execute the COPY command? Of course not needed! We can do this once with the ADD command:<\/p>\n

WORKDIR \/app
\nADD mohandir.tar.gz .<\/p>\n

This should be the best use case for the ADD command!<\/p>\n

Copying files from url to images
\nis a much more cool usage! However, in the best practices of the official documentation of docker , it is strongly recommended not to use this! ! The docker officially recommends that when we need to copy files from a remote location, it is best to use the curl or wget commands instead of the ADD command. The reason is that when using the ADD command, more mirror layers are created, and of course the size of the image will be larger (the two pieces of code below are from the docker official documentation):<\/p>\n

ADD http:\/\/example.com\/big.tar.xz \/usr\/src\/things\/
\nRUN tar -xJf \/usr\/src\/things\/big.tar.xz -C \/usr\/src\/things
\nRUN make -C \/ Usr\/src\/things all<\/p>\n

If you use the following command, not only does the number of layers in the image decrease, but the big.tar.xz file is also not included in the image:<\/p>\n

RUN mkdir -p \/usr\/src\/things \\
\n&& curl -SL http:\/\/example.com\/big.tar.xz \\
\n| tar -xJC \/usr\/src\/things \\
\n&& make -C \/usr\/src\/things All<\/p>\n

Well, it seems that the ADD command is only needed when extracting compressed files and adding them to the image!<\/p>\n

Tips for speeding up image construction
\nWhen using the COPY and ADD commands, we can use some tricks to speed up the mirror build process. For example, put the copy operation of the files that are least likely to change in the lower mirror layer, so that the cache generated by the previous build will be used when rebuilding the image. For example, the author needs to use the following files when building a mirror:<\/p>\n

As shown in the figure above, the second step and the third step do not rebuild the mirror layer, but use the previous cache. From the fourth step, the mirror layer is rebuilt. When the file size is large and the number of files is large, especially when you need to perform operations such as installation, such a design is still very obvious for the speed of the build. So we should try to choose the Dockerfile method that can use the cache.<\/p>\n

to sum up
\nWhen you first see the COPY and ADD commands, you can’t help wondering. But after analysis, you will find that the COPY command is designed for the most basic usage, with clear concepts and simple operation. The ADD command is basically a superset of the COPY command (except for the multistage scenario), which allows for some convenient and cool copy operations. The ADD command adds complexity to its use, such as copying compressed files from urls. I hope this article can solve everyone’s doubts about the COPY and ADD commands in the Dockerfile<\/p>\n","protected":false},"excerpt":{"rendered":"

COPY and ADD commands in Dockerfile<\/p>\n

Two very similar commands COPY and ADD are provided in the Dockerfile. This article attempts to explain the basic functions of these two commands, as well as their similarities and differences, and then summarize their respective suitable application scenarios.<\/p>\n

Build context concept When you create a mirror from a […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[82],"tags":[],"_links":{"self":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/7735"}],"collection":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=7735"}],"version-history":[{"count":2,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/7735\/revisions"}],"predecessor-version":[{"id":7737,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/7735\/revisions\/7737"}],"wp:attachment":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=7735"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=7735"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=7735"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}