github.com/jogo/docker@v1.7.0-rc1/docs/sources/reference/glossary.md (about)

     1  page_title: Docker Glossary
     2  page_description: Glossary of terms used around Docker
     3  page_keywords: glossary, docker, terms, definitions
     4  
     5  # Glossary
     6  
     7  A list of terms used around the Docker project.
     8  
     9  ## aufs
    10  
    11  aufs (advanced multi layered unification filesystem) is a Linux [filesystem](#filesystem) that
    12  Docker supports as a storage backend. It implements the
    13  [union mount](http://en.wikipedia.org/wiki/Union_mount) for Linux file systems.
    14  
    15  ## boot2docker
    16  
    17  [boot2docker](http://boot2docker.io/) is a lightweight Linux distribution made
    18  specifically to run Docker containers. It is a common choice for a [VM](#virtual-machine)
    19  to run Docker on Windows and Mac OS X.
    20  
    21  boot2docker can also refer to the boot2docker management tool on Windows and
    22  Mac OS X which manages the boot2docker VM.
    23  
    24  ## btrfs
    25  
    26  btrfs (B-tree file system) is a Linux [filesystem](#filesystem) that Docker
    27  supports as a storage backend. It is a [copy-on-write](http://en.wikipedia.org/wiki/Copy-on-write)
    28  filesystem.
    29  
    30  ## build
    31  
    32  build is the process of building Docker images using a [Dockerfile](#dockerfile).
    33  The build uses a Dockerfile and a "context". The context is the set of files in the
    34  directory in which the image is built.
    35  
    36  ## cgroups
    37  
    38  cgroups is a Linux kernel feature that limits, accounts for, and isolates
    39  the resource usage (CPU, memory, disk I/O, network, etc.) of a collection
    40  of processes. Docker relies on cgroups to control and isolate resource limits.
    41  
    42  *Also known as : control groups*
    43  
    44  ## Compose
    45  
    46  [Compose](https://github.com/docker/compose) is a tool for defining and
    47  running complex applications with Docker. With compose, you define a
    48  multi-container application in a single file, then spin your
    49  application up in a single command which does everything that needs to
    50  be done to get it running.
    51  
    52  *Also known as : docker-compose, fig*
    53  
    54  ## container
    55  
    56  A container is a runtime instance of a [docker image](#image).
    57  
    58  A Docker container consists of
    59  
    60  - A Docker image
    61  - Execution environment
    62  - A standard set of instructions
    63  
    64  The concept is borrowed from Shipping Containers, which define a standard to ship
    65  goods globally. Docker defines a standard to ship software.
    66  
    67  ## data volume
    68  
    69  A data volume is a specially-designated directory within one or more containers
    70  that bypasses the Union File System. Data volumes are designed to persist data,
    71  independent of the container's life cycle. Docker therefore never automatically
    72  delete volumes when you remove a container, nor will it "garbage collect"
    73  volumes that are no longer referenced by a container.
    74  
    75  
    76  ## Docker
    77  
    78  The term Docker can refer to
    79  
    80  - The Docker project as a whole, which is a platform for developers and sysadmins to
    81  develop, ship, and run applications
    82  - The docker daemon process running on the host which manages images and containers
    83  
    84  
    85  ## Docker Hub
    86  
    87  The [Docker Hub](https://hub.docker.com/) is a centralized resource for working with
    88  Docker and its components. It provides the following services:
    89  
    90  - Docker image hosting
    91  - User authentication
    92  - Automated image builds and work-flow tools such as build triggers and web hooks
    93  - Integration with GitHub and BitBucket
    94  
    95  
    96  ## Dockerfile
    97  
    98  A Dockerfile is a text document that contains all the commands you would
    99  normally execute manually in order to build a Docker image. Docker can
   100  build images automatically by reading the instructions from a Dockerfile.
   101  
   102  ## filesystem
   103  
   104  A file system is the method an operating system uses to name files
   105  and assign them locations for efficient storage and retrieval.
   106  
   107  Examples :
   108  
   109  - Linux : ext4, aufs, btrfs, zfs
   110  - Windows : NTFS
   111  - OS X : HFS+
   112  
   113  ## image
   114  
   115  Docker images are the basis of [containers](#container). An Image is an
   116  ordered collection of root filesystem changes and the corresponding
   117  execution parameters for use within a container runtime. An image typically
   118  contains a union of layered filesystems stacked on top of each other. An image
   119  does not have state and it never changes.
   120  
   121  ## libcontainer
   122  
   123  libcontainer provides a native Go implementation for creating containers with
   124  namespaces, cgroups, capabilities, and filesystem access controls. It allows
   125  you to manage the lifecycle of the container performing additional operations
   126  after the container is created.
   127  
   128  ## link
   129  
   130  links provide an interface to connect Docker containers running on the same host
   131  to each other without exposing the hosts' network ports. When you set up a link,
   132  you create a conduit between a source container and a recipient container.
   133  The recipient can then access select data about the source. To create a link,
   134  you can use the `--link` flag.
   135  
   136  ## Machine
   137  
   138  [Machine](https://github.com/docker/machine) is a Docker tool which
   139  makes it really easy to create Docker hosts on  your computer, on
   140  cloud providers and inside your own data center. It creates servers,
   141  installs Docker on them, then configures the Docker client to talk to them.
   142  
   143  *Also known as : docker-machine*
   144  
   145  ## overlay
   146  
   147  OverlayFS is a [filesystem](#filesystem) service for Linux which implements a
   148  [union mount](http://en.wikipedia.org/wiki/Union_mount) for other file systems.
   149  It is supported by the Docker daemon as a storage driver.
   150  
   151  ## registry
   152  
   153  A Registry is a hosted service containing [repositories](#repository) of [images](#image)
   154  which responds to the Registry API.
   155  
   156  The default registry can be accessed using a browser at [Docker Hub](#docker-hub)
   157  or using the `docker search` command.
   158  
   159  ## repository
   160  
   161  A repository is a set of Docker images. A repository can be shared by pushing it
   162  to a [registry](#registry) server. The different images in the repository can be
   163  labeled using [tags](#tag).
   164  
   165  Here is an example of the shared [nginx repository](https://registry.hub.docker.com/_/nginx/)
   166  and its [tags](https://registry.hub.docker.com/_/nginx/tags/manage/)
   167  
   168  ## Swarm
   169  
   170  [Swarm](https://github.com/docker/swarm) is a native clustering tool for Docker.
   171  Swarm pools together several Docker hosts and exposes them as a single virtual
   172  Docker host. It serves the standard Docker API, so any tool that already works
   173  with Docker can now transparently scale up to multiple hosts.
   174  
   175  *Also known as : docker-swarm*
   176  
   177  ## tag
   178  
   179  A tag is a label applied to a Docker image in a [repository](#repository).
   180  tags are how various images in a repository are distinguished from each other.
   181  
   182  *Note : This label is not related to the key=value labels set for docker daemon*
   183  
   184  ## Union file system
   185  
   186  Union file systems, or UnionFS, are file systems that operate by creating layers, making them
   187  very lightweight and fast. Docker uses union file systems to provide the building
   188  blocks for containers.
   189  
   190  
   191  ## Virtual Machine
   192  
   193  A Virtual Machine is a program that emulates a complete computer and imitates dedicated hardware.
   194  It shares physical hardware resources with other users but isolates the operating system. The
   195  end user has the same experience on a Virtual Machine as they would have on dedicated hardware.
   196  
   197  Compared to to containers, a Virtual Machine is heavier to run, provides more isolation,
   198  gets its own set of resources and does minimal sharing.
   199  
   200  *Also known as : VM*
   201