Docker Compose
Docker Compose is a tool for defining and running applications composed of multiple containers through declarative configuration.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A Docker Compose file is a declarative configuration file that defines the services, containers, images, and related settings for a multi-container application.
- How it is used
- Uses Compose to manage a multi-container microservices application during local development and testing.
- How deep it goes
- Builds from a single-service configuration to multiple services, lifecycle commands, and live reload; uses Kubernetes instead for production.
- Examples
- Builds a video-streaming application with an Azure Storage service and MongoDB, then configures a history service for live reload.
- What you can do after
- Operate and configure a local multi-container application with Docker Compose, including builds, shutdown, and development volumes.
Learn Docker in a Month of Lunches, Second Edition
Docker Compose is a Docker tool for defining and running multi-container applications from a declarative configuration file.
- How it is used
- Defines and runs multi-container applications on one Docker Engine, including development, nonproduction environments, and local CI/CD smoke tests.
- How deep it goes
- Works through YAML structure, service options, lifecycle commands, scaling, projects, and environment overrides; distinguishes applying desired state from continuous reconciliation.
- Examples
- Uses a single-service to-do app, a three-service image gallery, scaled API containers, and development and test configuration overrides.
- What you can do after
- Operate/configure it to launch, inspect, scale, and recreate an app while varying project names and settings across environments.
Read how Learn Docker in a Month of Lunches, Second Edition explains Docker Compose →
Road to Kubernetes
The Docker Compose plugin is a Docker CLI extension that provides Docker Compose commands for defining and running multi-container applications.
- How it is used
- Replaces hard-to-remember Docker runtime arguments with repeatable configuration for local and virtual-machine container deployments.
- How deep it goes
- Works through service configuration, commands, networking, state, and deployment steps, then identifies scaling limits rather than covering every customization.
- Examples
- Uses Python and Node.js applications, plus NGINX and Redis services, to show configuration, communication, and production deployment.
- What you can do after
- Operate/configure Docker Compose to build, start, stop, and connect services locally, then deploy tagged images on a virtual machine.
Rust Servers, Services, and Apps
Docker Compose is a tool for defining and operating multi-container applications from a declarative configuration.
- How it is used
- Coordinates the database and Rust web-service containers during packaging and deployment.
- How deep it goes
- Works through YAML services and build, startup, networking, and request checks; leaves broader production operations outside scope.
- Examples
- Uses a two-service docker-compose.yml, Compose commands, network inspection, and a curl request returning database-backed records.
- What you can do after
- Operate/configure a Rust API and Postgres stack with Docker Compose, then verify connectivity and an HTTP response.
Read how Rust Servers, Services, and Apps explains Docker Compose →
Build Financial Software with Generative AI (From Scratch)
Docker Compose is a tool for defining and running multi-container Docker applications from a declarative configuration file.
- How it is used
- Coordinates containerized components for an ACH application and later builds API and dashboard services.
- How deep it goes
- Walks through incremental service setup, build and startup commands, browser checks, and common connection failures.
- Examples
- Uses CloudBeaver with PostgreSQL, a FastAPI service, and a dashboard connected to WireMock.
- What you can do after
- Operate and configure Docker Compose services, verify them in a browser, and investigate common startup and connection errors.
Read how Build Financial Software with Generative AI (From Scratch) explains Docker Compose →
Kubernetes for Developers
A Docker Compose file is a declarative configuration file that defines the services, images, and settings for a Docker Compose application.
- How it is used
- Provides a repeatable local environment for testing a containerized application and a handful of dependent services before Kubernetes deployment.
- How deep it goes
- Works through single-service setup, bind mounts, and multiple services, while leaving production orchestration to Kubernetes.
- Examples
- Uses a Python web server with port mapping, a locally mounted source folder, and a separate MySQL container.
- What you can do after
- Operate/configure it to build and run local services with saved settings and edit mounted application files without rebuilding the image.
Read how Kubernetes for Developers explains Docker Compose →
Quarkus in Action
Docker Compose is a tool for defining and running multi-container applications from a declarative configuration file.
- How it is used
- Deploys multiple production-oriented infrastructure providers together for a locally run microservice application.
- How deep it goes
- Shows file-based deployment, startup and teardown commands, container inspection, and configuration changes, but not Compose syntax internals.
- Examples
- Uses an infrastructure Compose file, twelve named containers, and explicit startup and shutdown commands.
- What you can do after
- Operate/configure a multi-container infrastructure deployment with the Docker Compose command-line interface.
AI Agents in Action, Second Edition
Docker Compose is a tool for defining and running multi-container applications from a declarative configuration file.
- How it is used
- Orchestrates multi-agent microservice stacks locally through one declarative deployment and lifecycle command.
- How deep it goes
- Defines services, builds, ports, environment variables, and dependencies, but does not detail container networking internals.
- Examples
- Uses a three-container agent stack, docker-compose.yaml, .env configuration, localhost:8000, logs, and optional localtunnel demos.
- What you can do after
- Operate/configure a local multi-agent stack by preparing environment variables, building services, checking routing, viewing logs, and stopping containers.
Read how AI Agents in Action, Second Edition explains Docker Compose →
Claude at Work
A Docker Compose file is a declarative configuration file describing application services, dependencies, and their runtime settings.
- How it is used
- Runs application components and their dependencies together locally as a practical check of generated scaffolding.
- How deep it goes
- Describes configured services, dependencies, and pinned versions, but does not detail Compose syntax or configuration internals.
- Examples
- Uses a Compose file for custom components and dependencies, then runs the stack with `docker compose up --build`.
- What you can do after
- Operate the local application stack by running `docker compose up --build`.
Architecting an Apache Iceberg Lakehouse
Docker Compose is a tool for defining and running multi-container applications from a declarative configuration file.
- How it is used
- Orchestrates a complete local Apache Iceberg lakehouse for development, testing, and hands-on integration.
- How deep it goes
- Defines images, containers, networks, ports, credentials, and startup commands, then verifies runtime status without detailing production deployment.
- Examples
- Uses a docker-compose.yml file, six service containers, mapped ports, a shared network, and docker ps verification.
- What you can do after
- Operate/configure a local lakehouse whose services ingest, catalog, store, query, and visualize Iceberg data.
Read how Architecting an Apache Iceberg Lakehouse explains Docker Compose →
ScyllaDB in Action
Docker Compose is a tool for defining and running applications composed of multiple Docker containers.
- How it is used
- Coordinates multiple containers for monitoring deployment and ScyllaDB cluster rebuilding.
- How deep it goes
- Explains compose files, shared networking, configuration mapping, and startup commands, but does not detail Compose file syntax.
- Examples
- Uses compose.yml files and docker compose up --detach to launch monitoring services or rebuild a three-node cluster.
- What you can do after
- Operate multi-container monitoring services and recreate a ScyllaDB cluster with docker compose up --detach.
Data Pipelines with Apache Airflow, Second Edition
Docker Compose is a tool for defining and managing multicontainer Docker applications using configuration files.
- How it is used
- Defines and runs reproducible multicontainer Airflow and data-pipeline environments through YAML service configurations.
- How deep it goes
- Explains YAML configuration, service composition, overrides, startup commands, exposed services, and container inspection, without detailing Compose internals.
- Examples
- Uses Airflow deployment commands and an NYC transportation pipeline with databases, APIs, object storage, file serving, and a web page.
- What you can do after
- Operate/configure Docker-based Airflow and data-pipeline environments, start their services, and inspect running containers.
Read how Data Pipelines with Apache Airflow, Second Edition explains Docker Compose →
Build Python Web Apps with Streamlit
Docker Compose is a Docker tool for defining and running applications composed of one or more containers through declarative configuration.
- How it is used
- Simplifies repeatable Docker startup for applications whose build, port, and volume options would otherwise require lengthy commands.
- How deep it goes
- Defines services and runtime settings through YAML, but does not descend into Docker Compose internals or multi-service orchestration.
- Examples
- Uses a fact-frenzy-app service, port mapping 8502:8501, and a .streamlit volume mounted into the container.
- What you can do after
- Operate/configure a Dockerized Streamlit app through docker-compose.yml and start it with docker-compose up.
Read how Build Python Web Apps with Streamlit explains Docker Compose →
gRPC Microservices in Go
A Docker Compose file is a YAML configuration file that defines and configures multi-container Docker applications and their services.
- How it is used
- Orchestrates a repeatable multi-container environment for microservice end-to-end tests.
- How deep it goes
- Defines YAML structure, service fields, health checks, database initialization, and service-specific configuration.
- Examples
- Uses MySQL 8.0.30, mounted SQL initialization, payment and order services, exposed ports, and Docker Compose CLI commands.
- What you can do after
- Operate a configured test stack through Docker Compose with service dependencies, readiness checks, mounted resources, and runtime settings.
Server-Side WebAssembly
Docker Compose is a tool for defining and managing applications composed of multiple Docker containers.
- How it is used
- Orchestrates the containers required to run a local wasmCloud ecosystem.
- How deep it goes
- Explains service definitions, dependencies, networking, environment variables, deployment commands, and HTTP verification.
- Examples
- Uses docker-compose.yaml, wadm.yaml, NATS, a wasmCloud host, an HTTP component, and a curl response.
- What you can do after
- Operate/configure a local wasmCloud deployment with Docker Compose and verify its HTTP endpoint.
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
Docker Compose is a tool for defining and running multi-container applications.
- How it is used
- Orchestrates multiple containers on one node through YAML and a Docker-compatible Podman service.
- How deep it goes
- Explains installation, socket setup, YAML definition, launch, inspection, stopping, and teardown.
- Examples
- Uses a web service with an image, bind mount, named volume, port mapping, and Podman inspection commands.
- What you can do after
- Operate multi-container applications through docker-compose against a rootless or rootful Podman socket.
Also covered in
- Spring AI in Action
- Crack Any Codebase with AIIn early access (MEAP)
- Pro ASP.NET Core 7, Tenth Edition
- Rust Web Development
- Shipping Go: Develop, deliver, discuss, design, and go again
- Kafka Streams in Action, Second Edition
- Developer Experience on KubernetesIn early access (MEAP)
- Logs and Telemetry
- Contract Testing in Action
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- YAMLYAML is a human-readable data serialization standard for representing structured data, commonly using indentation to express mappings and sequences.
- microservice architectureMicroservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- IP addressAn IP address is a numerical network-layer address identifying an interface or endpoint for communication over an Internet Protocol network.
Related concepts
- docker-compose.ymluses · A YAML configuration file that declares services and related settings, such as networks and volumes, for a multi-container application.
- agent orchestrationkind of · Agent orchestration is the coordination of agents, their tasks, tools, and interactions to accomplish a larger objective or workflow.
- distributed systemconfigures · A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
- containeruses · A software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
Questions about Docker Compose
What is Docker Compose?
Docker Compose is a tool for defining and running applications composed of multiple containers through declarative configuration.
Which Manning books explain Docker Compose?
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Learn Docker in a Month of Lunches, Second Edition, Road to Kubernetes, Rust Servers, Services, and Apps, Build Financial Software with Generative AI (From Scratch), Kubernetes for Developers, Quarkus in Action, AI Agents in Action, Second Edition and 8 more.
What should I know before learning Docker Compose?
Manning books that teach Docker Compose usually introduce container, YAML, microservice architecture and IP address first.
What is Docker Compose a kind of?
Docker Compose is a kind of agent orchestration. Agent orchestration is the coordination of agents, their tasks, tools, and interactions to accomplish a larger objective or workflow.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.















