Docker Compose

Docker Compose is a developer tool and configuration specification for defining, creating, starting, stopping, and managing applications composed of multiple containers. Users describe services, networks, volumes, environment variables, dependencies, and related runtime settings in a YAML file, traditionally named docker-compose.yml or compose.yaml. A Compose project can then be brought up as a coordinated application rather than requiring each container to be created and connected through separate command-line operations. The technology emerged from the broader container-development ecosystem around Fig, an early tool that simplified running groups of Docker containers. Docker acquired Fig in 2014 and developed its capabilities under the Docker Compose name. Compose became closely associated with local development, testing, demonstrations, and small-scale self-hosted deployments because it offered a relatively accessible way to reproduce an application's service topology on a developer workstation. A typical file might define a web application, a database, a cache, and supporting services, while keeping the configuration close to the source code. Compose's importance comes from abstraction rather than from a standalone hosted service. It provides a declarative application model and a familiar workflow for multi-container projects, allowing teams to share an environment definition across developers and automated systems. Its YAML format also helped establish a common vocabulary for service dependencies, port mappings, persistent storage, health checks, build instructions, and network isolation. Compose files have commonly served as onboarding artifacts, integration-test configurations, and reference environments even when production workloads ultimately run on Kubernetes, a cloud container platform, or another orchestrator. The original Compose implementation was written in Python and operated as a separate command-line program. Docker later introduced a Go-based second-generation implementation, Docker Compose V2, distributed as a Docker CLI plugin and invoked with commands such as docker compose. Compose V2 retained compatibility with much of the established file format while aligning the user experience more closely with the Docker CLI. The Compose Specification subsequently provided a platform-oriented description of the file model, with implementation and feature support evolving over time. Docker Compose is primarily used internationally by software developers, platform engineers, educators, open-source maintainers, and teams building containerized applications. It is not a general-purpose production orchestrator on the scale of Kubernetes, and Docker positions it mainly around development workflows and application management on a single Docker host or closely related environments. Nevertheless, Compose remains a recognizable Docker ecosystem brand because it lowers the operational barrier to running several cooperating services and provides a practical bridge between source repositories and containerized execution.

Docker Compose traces its origins to Fig, a tool created to make it easier to describe and run collections of Docker containers. Before tools such as Fig and Compose, developers commonly had to create containers individually, configure their networking manually, and remember the relationships among application services. A declarative project file offered a more reproducible alternative: the application topology could be stored with the code and used by other members of a team. Docker acquired Fig in 2014 and continued its development as Docker Compose. The new name connected the tool to Docker's expanding product ecosystem while preserving its central concept: a Compose project describes a group of services that are intended to operate together. Docker Compose files could specify images or build contexts, exposed ports, environment variables, links or dependencies, volumes, and networks. The result was especially useful for development stacks consisting of a web service and one or more supporting components such as a relational database, message broker, or cache. Compose became a widely used part of container-oriented development. It helped teams standardize local environments, made multi-service examples easier to distribute, and provided a convenient mechanism for running integration tests. Its YAML-based model also became a common reference point for people learning Docker networking, storage, service discovery, and container lifecycle management. Although Compose was sometimes used for small deployments, it was generally differentiated from cluster-scale orchestrators that provide scheduling, automated recovery, and distributed control across many hosts. The first major implementation was a Python command-line application commonly invoked as docker-compose. As Docker's tooling evolved, the company developed Compose V2 in Go and integrated it into the Docker CLI as a plugin. The newer interface is invoked as docker compose, without the historical hyphen. Compose V2 was designed to preserve the familiar project model while providing closer integration with Docker commands and a more maintainable implementation. Docker subsequently deprecated and retired the legacy Compose V1 line. The Compose Specification consolidated the description of Compose application files as a platform-oriented specification. It has been used as the basis for Compose implementations and related tooling, while individual implementations may differ in the features they support. Docker Desktop includes Compose capabilities, and Docker's documentation presents Compose as a way to define and run multi-container applications across common developer workflows. Today, Docker Compose remains an active Docker ecosystem product. Its principal audience includes application developers, DevOps and platform teams, educators, open-source projects, and organizations that need repeatable environments without adopting a full cluster orchestrator. Compose's durable role is as a practical application-definition layer: it turns a set of containerized services and their relationships into a shareable project that can be started, inspected, updated, and removed through a consistent workflow.

1. 2023Compose V1 reaches end of life

   Docker ended maintenance for Compose V1 and directed users to Compose V2.

   Source
2. 2021Compose V2 is integrated with the Docker CLI

   Docker promoted the Go-based Compose V2 implementation and the docker compose command as the successor to the legacy Python-based command.

   Source
3. 2020Compose Specification is introduced

   The Compose file model was documented as the Compose Specification, providing a common description of application structure and service configuration.

   Source
4. 2015Docker Compose becomes a Docker ecosystem tool

   The Fig-derived workflow was developed and distributed under the Docker Compose name for defining and running multi-container applications.

   Source
5. 2014Docker acquires Fig

   Docker acquired Fig, the multi-container development tool whose capabilities formed the basis of Docker Compose.

   Source

A declarative, developer-oriented way to model and operate multi-container applications, positioned between individual Docker container commands and larger production orchestration platforms.

• Docker Compose CLIDeveloper tool

  The command-line interface used to create and manage Compose projects. It supports operations such as starting, stopping, rebuilding, inspecting, and removing groups of services described in a Compose file. Modern Compose V2 is distributed as a Docker CLI plugin and uses the docker compose command.

• Compose SpecificationConfiguration specification2020

  A platform-oriented specification for describing multi-container applications. It defines concepts including services, networks, volumes, configurations, secrets, dependencies, and project-level settings, while implementations determine the exact supported feature set.

• Compose fileApplication definition

  The YAML project file that captures an application's services and their relationships. It can combine prebuilt images with locally built containers and describe networking, storage, environment configuration, health checks, and startup dependencies.

• Docker Desktop Compose integrationDesktop developer tooling

  Compose functionality bundled into Docker Desktop workflows, allowing desktop users to run and manage multi-container projects alongside images, containers, volumes, and other Docker resources.

• 2021Make Compose V2 the modern implementationGeneration change

  The original Compose implementation was a separate Python-based command-line tool, while Docker was consolidating its developer commands around the Docker CLI.

  What changed. Docker advanced Compose V2, a Go-based Docker CLI plugin invoked with docker compose, and began deprecating the legacy docker-compose command.

  Aftermath. Users were encouraged to migrate projects and scripts to Compose V2; the older implementation subsequently reached end of life.

  Source
• 2014Acquire Fig and develop it as Docker ComposeM&A

  Fig provided a developer-friendly method for defining and running groups of Docker containers. Docker's acquisition gave the company a direct foundation for a multi-container application workflow.

  What changed. Docker acquired Fig and incorporated its technology and team into Docker's product development, subsequently presenting the capability under the Docker Compose name.

  Aftermath. The acquisition helped establish Compose as Docker's standard workflow for local and development-oriented multi-container applications.

  Source

• 2023Docker Compose V1 reaches end of life

  Docker documentation identified Compose V1 as no longer maintained and directed users toward Compose V2. The change completed the transition from the legacy docker-compose command to the Docker CLI-integrated implementation.

  Product generation
  Source
• 2021Docker Compose V2 becomes the recommended Compose implementation

  Docker moved Compose V2, implemented in Go and integrated with the Docker CLI, toward recommended use while the older Python-based Compose V1 entered deprecation. The transition introduced the docker compose command as the modern command form.

  Product generation
  Source
• 2014Docker acquires Fig and brings its multi-container workflow into Docker

  Docker announced the acquisition of Fig, a tool for defining and running groups of Docker containers. The technology became the foundation for Docker Compose and expanded Docker's developer workflow beyond operating individual containers.

  M&A
  Source

1. Docker Compose documentation
2. Docker Compose V2 migration documentation
3. Compose Specification
4. Docker acquires Fig
5. Docker Compose source repository