github.com/a4a881d4/docker@v1.9.0-rc2/docs/reference/glossary.md (about)

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