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
- Runs and manages a multi-container microservices application for local development and testing.
- How deep it goes
- Works from a single-service YAML file through added services, lifecycle commands, and live-reload volumes; defers production orchestration to Kubernetes.
- Examples
- Uses a video-streaming service, a storage service, a MongoDB container, command listings, and a live-reload configuration.
- What you can do after
- Build it from scratch as a local Compose application, then start, inspect, and shut down its containers with `docker compose`.
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 API, database, dashboard, and support containers from a centralized declarative configuration.
- How deep it goes
- Walks through incremental service definitions, builds, ports, variables, dependencies, startup commands, and common connection failures.
- Examples
- Uses CloudBeaver and PostgreSQL containers, a FastAPI API, and a dashboard configured with a WireMock API URL.
- What you can do after
- Operate/configure it to build, start, expose, connect, and troubleshoot a small multi-container application.
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 →
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.
Related concepts
- docker-compose.ymluses · docker-compose.yml is a declarative YAML configuration file that defines Docker Compose application services and their containers, networks, volumes, and runtime settings.
- agent orchestrationkind of · Orchestration is the coordination and sequencing of agents, services, tasks, or components to carry out a larger workflow or objective.
- 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 while sharing the host operating system kernel.
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.