NAME

       docker-container-cp - Copy files/folders between a container and the local filesystem

SYNOPSIS

       docker  container  cp  [OPTIONS]  CONTAINER:SRC_PATH  DEST_PATH|-       docker  cp  [OPTIONS]  SRC_PATH|-
       CONTAINER:DEST_PATH

DESCRIPTION

       The docker container cp utility copies the contents of SRC_PATH to the DEST_PATH.  You can copy from  the
       container's  file system to the local machine or the reverse, from the local filesystem to the container.
       If - is specified for either the SRC_PATH or DEST_PATH, you can also stream a tar archive from  STDIN  or
       to  STDOUT. The CONTAINER can be a running or stopped container.  The SRC_PATH or DEST_PATH can be a file
       or directory.

       The docker container cp command assumes  container  paths  are  relative  to  the  container's  /  (root)
       directory.   This   means   supplying   the   initial   forward  slash  is  optional;  The  command  sees
       compassionate_darwin:/tmp/foo/myfile.txt and compassionate_darwin:tmp/foo/myfile.txt as identical.  Local
       machine  paths  can  be  an absolute or relative value. The command interprets a local machine's relative
       paths as relative to the current working directory where docker container cp is run.

       The cp command behaves like the Unix cp -a command  in  that  directories  are  copied  recursively  with
       permissions preserved if possible. Ownership is set to the user and primary group at the destination. For
       example, files copied to a container are created with UID:GID of the root user. Files copied to the local
       machine  are  created with the UID:GID of the user which invoked the docker container cp command.  If you
       specify the -L option, docker container cp follows any symbolic link in the SRC_PATH. docker container cp
       does not create parent directories for DEST_PATH if they do not exist.

       Assuming a path separator of /, a first argument of  SRC_PATH  and  second  argument  of  DEST_PATH,  the
       behavior is as follows:

       • SRC_PATH specifies a file

         • DEST_PATH does not exist

           • the file is saved to a file created at DEST_PATH

         • DEST_PATH does not exist and ends with /

           • Error condition: the destination directory must exist.

         • DEST_PATH exists and is a file

           • the destination is overwritten with the source file's contents

         • DEST_PATH exists and is a directory

           • the file is copied into this directory using the basename from SRC_PATH

       • SRC_PATH specifies a directory

         • DEST_PATH does not exist

           • DEST_PATH  is  created as a directory and the contents of the source directory are copied into this
             directory

         • DEST_PATH exists and is a file

           • Error condition: cannot copy a directory to a file

         • DEST_PATH exists and is a directory

           • SRC_PATH does not end with /. (that is: slash followed by dot)

             • the source directory is copied into this directory

           • SRC_PATH does end with /. (that is: slash followed by dot)

             • the content of the source directory is copied into this directory

       The command requires SRC_PATH and DEST_PATH to exist according to the above rules. If SRC_PATH  is  local
       and  is a symbolic link, the symbolic link, not the target, is copied by default. To copy the link target
       and not the link, specify the -L option.

       A colon (:) is used as a delimiter between CONTAINER and its path. You can also  use  :  when  specifying
       paths  to  a  SRC_PATH  or  DEST_PATH on a local machine, for example  file:name.txt. If you use a : in a
       local machine path, you must be explicit with a relative or absolute path, for example:

       `/path/to/file:name.txt` or `./file:name.txt`

       It is not possible to copy certain system files such as resources under /proc,  /sys,  /dev,  tmpfs,  and
       mounts  created by the user in the container.  However, you can still copy such files by manually running
       tar in docker exec.  For example (consider SRC_PATH and DEST_PATH are directories):

       $ docker exec foo tar Ccf $(dirname SRC_PATH) - $(basename SRC_PATH) | tar Cxf DEST_PATH -

       or

       $ tar Ccf $(dirname SRC_PATH) - $(basename SRC_PATH) | docker exec -i foo tar Cxf DEST_PATH -

       Using - as the SRC_PATH streams the contents of STDIN as a tar archive.  The command extracts the content
       of the tar to the DEST_PATH in container's filesystem. In this case, DEST_PATH must specify a  directory.
       Using - as the DEST_PATH streams the contents of the resource as a tar archive to STDOUT.

EXAMPLES

       Suppose a container has finished producing some output as a file it saves to somewhere in its filesystem.
       This  could  be  the output of a build job or some other computation. You can copy these outputs from the
       container to a location on your local host.

       If you want to copy the /tmp/foo directory from a container to the existing /tmp directory on your  host.
       If you run docker container cp in your ~ (home) directory on the local host:

       $ docker container cp compassionate_darwin:tmp/foo /tmp

       Docker  creates  a  /tmp/foo directory on your host. Alternatively, you can omit the leading slash in the
       command. If you execute this command from your home directory:

       $ docker container cp compassionate_darwin:tmp/foo tmp

       If ~/tmp does not exist, Docker will create it and copy the contents of /tmp/foo from the container  into
       this  new  directory.  If  ~/tmp  already  exists  as  a directory, then Docker will copy the contents of
       /tmp/foo from the container into a directory at ~/tmp/foo.

       When copying a single file to an  existing  LOCALPATH,  the  docker  container  cp  command  will  either
       overwrite  the  contents  of  LOCALPATH  if it is a file or place it into LOCALPATH if it is a directory,
       overwriting an existing file of the same name if one exists. For example, this command:

       $ docker container cp sharp_ptolemy:/tmp/foo/myfile.txt /test

       If /test does not exist on the local machine, it  will  be  created  as  a  file  with  the  contents  of
       /tmp/foo/myfile.txt  from  the  container.  If /test exists as a file, it will be overwritten. Lastly, if
       /test exists as a directory, the file will be copied to /test/myfile.txt.

       Next, suppose you want to copy a file  or  folder  into  a  container.  For  example,  this  could  be  a
       configuration  file or some other input to a long running computation that you would like to place into a
       created container before it starts. This is useful because it does not require the configuration file  or
       other input to exist in the container image.

       If  you  have  a  file, config.yml, in the current directory on your local host and wish to copy it to an
       existing directory at /etc/my-app.d in a container, this command can be used:

       $ docker container cp config.yml myappcontainer:/etc/my-app.d

       If you have several files in a local directory /config which you need to copy  to  a  directory  /etc/my-
       app.d in a container:

       $ docker container cp /config/. myappcontainer:/etc/my-app.d

       The  above command will copy the contents of the local /config directory into the directory /etc/my-app.d
       in the container.

       Finally, if you want to copy a symbolic link into a container, you typically want  to   copy  the  linked
       target and not the link itself. To copy the target, use the -L option, for example:

       $ ln -s /tmp/somefile /tmp/somefile.ln
       $ docker container cp -L /tmp/somefile.ln myappcontainer:/tmp/

       This  command  copies content of the local /tmp/somefile into the file /tmp/somefile.ln in the container.
       Without -L option, the /tmp/somefile.ln preserves its symbolic link but not its content.

OPTIONS

       -a, --archive[=false]      Archive mode (copy all uid/gid information)

       -L, --follow-link[=false]      Always follow symbol link in SRC_PATH

       -h, --help[=false]      help for cp

       -q,  --quiet[=false]       Suppress  progress  output  during  copy.  Progress  output  is  automatically
       suppressed if no terminal is attached

SEE ALSO

       docker-container(1)

Docker Community                                    Feb 2025                                           DOCKER(1)