github.com/sijibomii/docker@v0.0.0-20231230191044-5cf6ca554647/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 a legacy interface to connect Docker containers running on the
   144  same host to each other without exposing the hosts' network ports. Use the
   145  Docker networks feature instead.
   146  
   147  ## Machine
   148  
   149  [Machine](https://github.com/docker/machine) is a Docker tool which
   150  makes it really easy to create Docker hosts on  your computer, on
   151  cloud providers and inside your own data center. It creates servers,
   152  installs Docker on them, then configures the Docker client to talk to them.
   153  
   154  *Also known as : docker-machine*
   155  
   156  ## overlay network driver
   157  
   158  Overlay network driver provides out of the box multi-host network connectivity
   159  for docker containers in a cluster.
   160  
   161  ## overlay storage driver
   162  
   163  OverlayFS is a [filesystem](#filesystem) service for Linux which implements a
   164  [union mount](http://en.wikipedia.org/wiki/Union_mount) for other file systems.
   165  It is supported by the Docker daemon as a storage driver.
   166  
   167  ## registry
   168  
   169  A Registry is a hosted service containing [repositories](#repository) of [images](#image)
   170  which responds to the Registry API.
   171  
   172  The default registry can be accessed using a browser at [Docker Hub](#docker-hub)
   173  or using the `docker search` command.
   174  
   175  ## repository
   176  
   177  A repository is a set of Docker images. A repository can be shared by pushing it
   178  to a [registry](#registry) server. The different images in the repository can be
   179  labeled using [tags](#tag).
   180  
   181  Here is an example of the shared [nginx repository](https://hub.docker.com/_/nginx/)
   182  and its [tags](https://hub.docker.com/r/library/nginx/tags/)
   183  
   184  ## Swarm
   185  
   186  [Swarm](https://github.com/docker/swarm) is a native clustering tool for Docker.
   187  Swarm pools together several Docker hosts and exposes them as a single virtual
   188  Docker host. It serves the standard Docker API, so any tool that already works
   189  with Docker can now transparently scale up to multiple hosts.
   190  
   191  *Also known as : docker-swarm*
   192  
   193  ## tag
   194  
   195  A tag is a label applied to a Docker image in a [repository](#repository).
   196  tags are how various images in a repository are distinguished from each other.
   197  
   198  *Note : This label is not related to the key=value labels set for docker daemon*
   199  
   200  ## Toolbox
   201  
   202  Docker Toolbox is the installer for Mac and Windows users.
   203  
   204  
   205  ## Union file system
   206  
   207  Union file systems, or UnionFS, are file systems that operate by creating layers, making them
   208  very lightweight and fast. Docker uses union file systems to provide the building
   209  blocks for containers.
   210  
   211  
   212  ## Virtual Machine
   213  
   214  A Virtual Machine is a program that emulates a complete computer and imitates dedicated hardware.
   215  It shares physical hardware resources with other users but isolates the operating system. The
   216  end user has the same experience on a Virtual Machine as they would have on dedicated hardware.
   217  
   218  Compared to to containers, a Virtual Machine is heavier to run, provides more isolation,
   219  gets its own set of resources and does minimal sharing.
   220  
   221  *Also known as : VM*