github.com/0xfoo/docker@v1.8.2/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  ## boot2docker
    23  
    24  [boot2docker](http://boot2docker.io/) is a lightweight Linux distribution made
    25  specifically to run Docker containers. It is a common choice for a [VM](#virtual-machine)
    26  to run Docker on Windows and Mac OS X.
    27  
    28  boot2docker can also refer to the boot2docker management tool on Windows and
    29  Mac OS X which manages the boot2docker VM.
    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  ## link
   136  
   137  links provide an interface to connect Docker containers running on the same host
   138  to each other without exposing the hosts' network ports. When you set up a link,
   139  you create a conduit between a source container and a recipient container.
   140  The recipient can then access select data about the source. To create a link,
   141  you can use the `--link` flag.
   142  
   143  ## Machine
   144  
   145  [Machine](https://github.com/docker/machine) is a Docker tool which
   146  makes it really easy to create Docker hosts on  your computer, on
   147  cloud providers and inside your own data center. It creates servers,
   148  installs Docker on them, then configures the Docker client to talk to them.
   149  
   150  *Also known as : docker-machine*
   151  
   152  ## overlay
   153  
   154  OverlayFS is a [filesystem](#filesystem) service for Linux which implements a
   155  [union mount](http://en.wikipedia.org/wiki/Union_mount) for other file systems.
   156  It is supported by the Docker daemon as a storage driver.
   157  
   158  ## registry
   159  
   160  A Registry is a hosted service containing [repositories](#repository) of [images](#image)
   161  which responds to the Registry API.
   162  
   163  The default registry can be accessed using a browser at [Docker Hub](#docker-hub)
   164  or using the `docker search` command.
   165  
   166  ## repository
   167  
   168  A repository is a set of Docker images. A repository can be shared by pushing it
   169  to a [registry](#registry) server. The different images in the repository can be
   170  labeled using [tags](#tag).
   171  
   172  Here is an example of the shared [nginx repository](https://registry.hub.docker.com/_/nginx/)
   173  and its [tags](https://registry.hub.docker.com/_/nginx/tags/manage/)
   174  
   175  ## Swarm
   176  
   177  [Swarm](https://github.com/docker/swarm) is a native clustering tool for Docker.
   178  Swarm pools together several Docker hosts and exposes them as a single virtual
   179  Docker host. It serves the standard Docker API, so any tool that already works
   180  with Docker can now transparently scale up to multiple hosts.
   181  
   182  *Also known as : docker-swarm*
   183  
   184  ## tag
   185  
   186  A tag is a label applied to a Docker image in a [repository](#repository).
   187  tags are how various images in a repository are distinguished from each other.
   188  
   189  *Note : This label is not related to the key=value labels set for docker daemon*
   190  
   191  ## Union file system
   192  
   193  Union file systems, or UnionFS, are file systems that operate by creating layers, making them
   194  very lightweight and fast. Docker uses union file systems to provide the building
   195  blocks for containers.
   196  
   197  
   198  ## Virtual Machine
   199  
   200  A Virtual Machine is a program that emulates a complete computer and imitates dedicated hardware.
   201  It shares physical hardware resources with other users but isolates the operating system. The
   202  end user has the same experience on a Virtual Machine as they would have on dedicated hardware.
   203  
   204  Compared to to containers, a Virtual Machine is heavier to run, provides more isolation,
   205  gets its own set of resources and does minimal sharing.
   206  
   207  *Also known as : VM*
   208