github.com/olljanat/moby@v1.13.1/docs/reference/glossary.md (about)

     1  ---
     2  title: "Docker Glossary"
     3  description: "Glossary of terms used around Docker"
     4  keywords: "glossary, docker, terms, definitions"
     5  ---
     6  
     7  <!-- This file is maintained within the docker/docker Github
     8       repository at https://github.com/docker/docker/. Make all
     9       pull requests against that repo. If you see this file in
    10       another repository, consider it read-only there, as it will
    11       periodically be overwritten by the definitive file. Pull
    12       requests which include edits to this file in other repositories
    13       will be rejected.
    14  -->
    15  
    16  # Glossary
    17  
    18  A list of terms used around the Docker project.
    19  
    20  ## aufs
    21  
    22  aufs (advanced multi layered unification filesystem) is a Linux [filesystem](#filesystem) that
    23  Docker supports as a storage backend. It implements the
    24  [union mount](http://en.wikipedia.org/wiki/Union_mount) for Linux file systems.
    25  
    26  ## base image
    27  
    28  An image that has no parent is a **base image**.
    29  
    30  ## boot2docker
    31  
    32  [boot2docker](http://boot2docker.io/) is a lightweight Linux distribution made
    33  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.
    34  
    35  ## btrfs
    36  
    37  btrfs (B-tree file system) is a Linux [filesystem](#filesystem) that Docker
    38  supports as a storage backend. It is a [copy-on-write](http://en.wikipedia.org/wiki/Copy-on-write)
    39  filesystem.
    40  
    41  ## build
    42  
    43  build is the process of building Docker images using a [Dockerfile](#dockerfile).
    44  The build uses a Dockerfile and a "context". The context is the set of files in the
    45  directory in which the image is built.
    46  
    47  ## cgroups
    48  
    49  cgroups is a Linux kernel feature that limits, accounts for, and isolates
    50  the resource usage (CPU, memory, disk I/O, network, etc.) of a collection
    51  of processes. Docker relies on cgroups to control and isolate resource limits.
    52  
    53  *Also known as : control groups*
    54  
    55  ## Compose
    56  
    57  [Compose](https://github.com/docker/compose) is a tool for defining and
    58  running complex applications with Docker. With compose, you define a
    59  multi-container application in a single file, then spin your
    60  application up in a single command which does everything that needs to
    61  be done to get it running.
    62  
    63  *Also known as : docker-compose, fig*
    64  
    65  ## container
    66  
    67  A container is a runtime instance of a [docker image](#image).
    68  
    69  A Docker container consists of
    70  
    71  - A Docker image
    72  - Execution environment
    73  - A standard set of instructions
    74  
    75  The concept is borrowed from Shipping Containers, which define a standard to ship
    76  goods globally. Docker defines a standard to ship software.
    77  
    78  ## data volume
    79  
    80  A data volume is a specially-designated directory within one or more containers
    81  that bypasses the Union File System. Data volumes are designed to persist data,
    82  independent of the container's life cycle. Docker therefore never automatically
    83  delete volumes when you remove a container, nor will it "garbage collect"
    84  volumes that are no longer referenced by a container.
    85  
    86  
    87  ## Docker
    88  
    89  The term Docker can refer to
    90  
    91  - The Docker project as a whole, which is a platform for developers and sysadmins to
    92  develop, ship, and run applications
    93  - The docker daemon process running on the host which manages images and containers
    94  
    95  
    96  ## Docker Hub
    97  
    98  The [Docker Hub](https://hub.docker.com/) is a centralized resource for working with
    99  Docker and its components. It provides the following services:
   100  
   101  - Docker image hosting
   102  - User authentication
   103  - Automated image builds and work-flow tools such as build triggers and web hooks
   104  - Integration with GitHub and Bitbucket
   105  
   106  
   107  ## Dockerfile
   108  
   109  A Dockerfile is a text document that contains all the commands you would
   110  normally execute manually in order to build a Docker image. Docker can
   111  build images automatically by reading the instructions from a Dockerfile.
   112  
   113  ## filesystem
   114  
   115  A file system is the method an operating system uses to name files
   116  and assign them locations for efficient storage and retrieval.
   117  
   118  Examples :
   119  
   120  - Linux : ext4, aufs, btrfs, zfs
   121  - Windows : NTFS
   122  - macOS : HFS+
   123  
   124  ## image
   125  
   126  Docker images are the basis of [containers](#container). An Image is an
   127  ordered collection of root filesystem changes and the corresponding
   128  execution parameters for use within a container runtime. An image typically
   129  contains a union of layered filesystems stacked on top of each other. An image
   130  does not have state and it never changes.
   131  
   132  ## libcontainer
   133  
   134  libcontainer provides a native Go implementation for creating containers with
   135  namespaces, cgroups, capabilities, and filesystem access controls. It allows
   136  you to manage the lifecycle of the container performing additional operations
   137  after the container is created.
   138  
   139  ## libnetwork
   140  
   141  libnetwork provides a native Go implementation for creating and managing container
   142  network namespaces and other network resources. It manage the networking lifecycle
   143  of the container performing additional operations after the container is created.
   144  
   145  ## link
   146  
   147  links provide a legacy interface to connect Docker containers running on the
   148  same host to each other without exposing the hosts' network ports. Use the
   149  Docker networks feature instead.
   150  
   151  ## Machine
   152  
   153  [Machine](https://github.com/docker/machine) is a Docker tool which
   154  makes it really easy to create Docker hosts on  your computer, on
   155  cloud providers and inside your own data center. It creates servers,
   156  installs Docker on them, then configures the Docker client to talk to them.
   157  
   158  *Also known as : docker-machine*
   159  
   160  ## node
   161  
   162  A [node](https://docs.docker.com/engine/swarm/how-swarm-mode-works/nodes/) is a physical or virtual
   163  machine running an instance of the Docker Engine in swarm mode.
   164  
   165  **Manager nodes** perform swarm management and orchestration duties. By default
   166  manager nodes are also worker nodes.
   167  
   168  **Worker nodes** execute tasks.
   169  
   170  ## overlay network driver
   171  
   172  Overlay network driver provides out of the box multi-host network connectivity
   173  for docker containers in a cluster.
   174  
   175  ## overlay storage driver
   176  
   177  OverlayFS is a [filesystem](#filesystem) service for Linux which implements a
   178  [union mount](http://en.wikipedia.org/wiki/Union_mount) for other file systems.
   179  It is supported by the Docker daemon as a storage driver.
   180  
   181  ## registry
   182  
   183  A Registry is a hosted service containing [repositories](#repository) of [images](#image)
   184  which responds to the Registry API.
   185  
   186  The default registry can be accessed using a browser at [Docker Hub](#docker-hub)
   187  or using the `docker search` command.
   188  
   189  ## repository
   190  
   191  A repository is a set of Docker images. A repository can be shared by pushing it
   192  to a [registry](#registry) server. The different images in the repository can be
   193  labeled using [tags](#tag).
   194  
   195  Here is an example of the shared [nginx repository](https://hub.docker.com/_/nginx/)
   196  and its [tags](https://hub.docker.com/r/library/nginx/tags/)
   197  
   198  
   199  ## service
   200  
   201  A [service](https://docs.docker.com/engine/swarm/how-swarm-mode-works/services/) is the definition of how
   202  you want to run your application containers in a swarm. At the most basic level
   203  a service  defines which container image to run in the swarm and which commands
   204  to run in the container. For orchestration purposes, the service defines the
   205  "desired state", meaning how many containers to run as tasks and constraints for
   206  deploying the containers.
   207  
   208  Frequently a service is a microservice within the context of some larger
   209  application. Examples of services might include an HTTP server, a database, or
   210  any other type of executable program that you wish to run in a distributed
   211  environment.
   212  
   213  ## service discovery
   214  
   215  Swarm mode [service discovery](https://docs.docker.com/engine/swarm/networking/#use-swarm-mode-service-discovery) is a DNS component
   216  internal to the swarm that automatically assigns each service on an overlay
   217  network in the swarm a VIP and DNS entry. Containers on the network share DNS
   218  mappings for the service via gossip so any container on the network can access
   219  the service via its service name.
   220  
   221  You don’t need to expose service-specific ports to make the service available to
   222  other services on the same overlay network. The swarm’s internal load balancer
   223  automatically distributes requests to the service VIP among the active tasks.
   224  
   225  ## swarm
   226  
   227  A [swarm](https://docs.docker.com/engine/swarm/) is a cluster of one or more Docker Engines running in [swarm mode](#swarm-mode).
   228  
   229  ## Docker Swarm
   230  
   231  Do not confuse [Docker Swarm](https://github.com/docker/swarm) with the [swarm mode](#swarm-mode) features in Docker Engine.
   232  
   233  Docker Swarm is the name of a standalone native clustering tool for Docker.
   234  Docker Swarm pools together several Docker hosts and exposes them as a single
   235  virtual Docker host. It serves the standard Docker API, so any tool that already
   236  works with Docker can now transparently scale up to multiple hosts.
   237  
   238  *Also known as : docker-swarm*
   239  
   240  ## swarm mode
   241  
   242  [Swarm mode](https://docs.docker.com/engine/swarm/) refers to cluster management and orchestration
   243  features embedded in Docker Engine. When you initialize a new swarm (cluster) or
   244  join nodes to a swarm, the Docker Engine runs in swarm mode.
   245  
   246  ## tag
   247  
   248  A tag is a label applied to a Docker image in a [repository](#repository).
   249  tags are how various images in a repository are distinguished from each other.
   250  
   251  *Note : This label is not related to the key=value labels set for docker daemon*
   252  
   253  ## task
   254  
   255  A [task](https://docs.docker.com/engine/swarm/how-swarm-mode-works/services/#/tasks-and-scheduling) is the
   256  atomic unit of scheduling within a swarm. A task carries a Docker container and
   257  the commands to run inside the container. Manager nodes assign tasks to worker
   258  nodes according to the number of replicas set in the service scale.
   259  
   260  The diagram below illustrates the relationship of services to tasks and
   261  containers.
   262  
   263  ![services diagram](https://docs.docker.com/engine/swarm/images/services-diagram.png)
   264  
   265  ## Toolbox
   266  
   267  Docker Toolbox is the installer for Mac and Windows users.
   268  
   269  
   270  ## Union file system
   271  
   272  Union file systems, or UnionFS, are file systems that operate by creating layers, making them
   273  very lightweight and fast. Docker uses union file systems to provide the building
   274  blocks for containers.
   275  
   276  
   277  ## virtual machine
   278  
   279  A virtual machine is a program that emulates a complete computer and imitates dedicated hardware.
   280  It shares physical hardware resources with other users but isolates the operating system. The
   281  end user has the same experience on a Virtual Machine as they would have on dedicated hardware.
   282  
   283  Compared to containers, a virtual machine is heavier to run, provides more isolation,
   284  gets its own set of resources and does minimal sharing.
   285  
   286  *Also known as : VM*