Docker ADD vs VOLUME

I am learning Docker and I have doubts about when and where to use ADD and VOLUME. Here is what I think both of these do:

ADD

Copy files to the image at build time. The image has all the files so you can deploy very easily. On the other hand, needing to build every time doesn’t look like a good idea in development because building requires the developer to run a command to rebuild the container; additionally, building the container can be time-consuming.

  • How to collect docker logs to a particular docker container in compose?
  • How can I connect my docker to the internet?
  • Change process limit of open file descriptors inside a container [duplicate]
  • Send request from one docker container to another
  • Issues with network traffic from docker
  • How to connect two docker containers through localhost?
  • VOLUME

    I understand that using docker run -v you can mount a host folder inside your container, this way you can easily modify files and watch the app in your container react to the changes. It looks great in development, but I am not sure how to deploy my files this way.

  • Docker-compose build blocked after saying “Building <service>”
  • Docker container with Jmeter Jenkins stops after some time
  • Monitoring docker container from docker-java API
  • Runtime constraints on CPU and memory with docker containers
  • Creating user in gerrit through ssh
  • How to run docker to process host file
  • 2 Solutions collect form web for “Docker ADD vs VOLUME”

    ADD

    The fundamental difference between these two is that ADD makes whatever you’re adding, be it a folder or just a file actually part of your image. Anyone who uses the image you’ve built afterwards will have access to whatever you ADD. This is true even if you afterwards remove it because Docker works in layers and the ADD layer will still exist as part of the image. To be clear, you only ADD something at build time and cannot ever ADD at run-time.

    A few examples of cases where you’d want to use ADD:

    • You have some requirements in a requirements.txt file that you want to reference and install in your Dockerfile. You can then do: ADD ./requirements.txt /requirements.txt followed by RUN pip install -r /requirements.txt
    • You want to use your app code as context in your Dockerfile, for example, if you want to set your app directory as the working dir in your image and to have the default command in a container run from your image actually run your app, you can do:

      ADD ./ /usr/local/git/my_app

      WORKDIR /usr/local/git/my_app

      CMD python ./main.py

    VOLUME

    Volume, on the other hand, just lets a container run from your image have access to some path on whatever local machine the container is being run on. You cannot use files from your VOLUME directory in your Dockerfile. Anything in your volume directory will not be accessible at build-time but will be accessible at run-time.

    A few examples of cases where you’d want to use VOLUME:

    • The app being run in your container makes logs in /var/log/my_app. You want those logs to be accessible on the host machine and not to be deleted when the container is removed. You can do this by creating a mount point at /var/log/my_app by adding VOLUME /var/log/my_app to your Dockerfile and then running your container with docker run -v /host/log/dir/my_app:/var/log/my_app some_repo/some_image:some_tag
    • You have some local settings files you want the app in the container to have access to. Perhaps those settings files are different on your local machine vs dev vs production. Especially so if those settings files are secret, in which case you definitely do not want them in your image. A good strategy in that case is to add VOLUME /etc/settings/my_app_settings to your Dockerfile, run your container with docker run -v /host/settings/dir:/etc/settings/my_app_settings some_repo/some_image:some_tag, and make sure the /host/settings/dir exists in all environments you expect your app to be run.

    The VOLUME instruction creates a data volume in your Docker container at runtime. The directory provided as an argument to VOLUME is a directory that bypasses the Union File System, and is primarily used for persistent and shared data.

    If you run docker inspect <your-container>, you will see under the Mounts section there is a Source which represents the directory location on the host, and a Destination which represents the mounted directory location in the container. For example,

    "Mounts": [
      {
        "Name": "fac362...80535",
        "Source": "/var/lib/docker/volumes/fac362...80535/_data",
        "Destination": "/webapp",
        "Driver": "local",
        "Mode": "",
        "RW": true,
        "Propagation": ""
      }
    ]
    

    Here are 3 use cases for docker run -v:

    1. docker run -v /data: This is analogous to specifying the VOLUME instruction in your Dockerfile.
    2. docker run -v $host_path:$container_path: This allows you to mount $host_path from your host to $container_path in your container during runtime. In development, this is useful for sharing source code on your host with the container. In production, this can be used to mount things like the host’s DNS information (found in /etc/resolv.conf) or secrets into the container. Conversely, you can also use this technique to write the container’s logs into specific folders on the host. Both $host_path and $container_path must be absolute paths.
    3. docker run -v my_volume:$container_path: This creates a data volume in your container at $container_path and names it my_volume. It is essentially the same as creating and naming a volume using docker volume create my_volume. Naming a volume like this is useful for a container data volume and a shared-storage volume using a multi-host storage driver like Flocker.

    Notice that the approach of mounting a host folder as a data volume is not available in Dockerfile. To quote the docker documentation,

    Note: This is not available from a Dockerfile due to the portability and sharing purpose of it. As the host directory is, by its nature, host-dependent, a host directory specified in a Dockerfile probably wouldn’t work on all hosts.

    Now if you want to copy your files to containers in non-development environments, you can use the ADD or COPY instructions in your Dockerfile. These are what I usually use for non-development deployment.

    Docker will be the best open platform for developers and sysadmins to build, ship, and run distributed applications.