Container
A software container is an isolated execution environment that packages an application and its dependencies while sharing the host operating system kernel.
Learn Docker in a Month of Lunches, Second Edition
A container is an isolated software execution unit that packages an application with its dependencies for a compatible operating-system and processor platform.
- How it is used
- Runs packaged applications in isolated environments across development, testing, and production.
- How deep it goes
- Explains virtual resources, shared hosts, and hands-on Docker commands, while leaving low-level container runtime mechanisms aside.
- Examples
- Uses a Hello World run, an interactive terminal, a website-file exercise, and Windows IIS deployment.
- What you can do after
- Operate/configure it with Docker commands to run, connect to, inspect, and clean up containers.
Read how Learn Docker in a Month of Lunches, Second Edition explains container →
Kubernetes in Action, Second Edition
A container is an isolated execution environment that packages an application process with its dependencies while sharing the host operating system kernel.
- How it is used
- Packages separately managed application processes with their dependencies and serves as the workload run within Kubernetes pods.
- How deep it goes
- Explains images, lifecycle, namespaces, process behavior, and shared-kernel limits; introduces security mechanisms without fully explaining them.
- Examples
- Uses Docker process-inspection commands, a Node.js application container, and a Kubernetes Pod manifest.
- What you can do after
- Operate/configure it with Docker lifecycle commands and Kubernetes Pod definitions, and inspect its processes from inside or outside.
Read how Kubernetes in Action, Second Edition explains container →
Road to Kubernetes
A container is an isolated executable environment that packages an application with its dependencies while sharing the host operating system kernel.
- How it is used
- Uses containers to make application dependencies portable and reduce runtime setup on production virtual machines.
- How deep it goes
- Works through Dockerfile-based packaging, disposable containers, and basic Docker commands; defers intricate Dockerfiles and broader orchestration to later tools.
- Examples
- Uses a Python Dockerfile, an interactive Ubuntu-and-NGINX installation, and commands for running and inspecting NGINX containers.
- What you can do after
- Operate/configure it with Docker to build, run, inspect, and distribute application containers before deploying them with Kubernetes.
Rust Servers, Services, and Apps
An execution environment in which an application runs inside an isolated, portable software container.
- How it is used
- Packages Rust web services and Postgres for portable deployment, then runs them together as an application stack.
- How deep it goes
- Works through image creation, container execution, persistence, and orchestration; leaves broader production security and monitoring outside the walkthrough.
- Examples
- Uses a hello-world container, an Actix Web server, and separate API and Postgres containers tested through HTTP requests and database restarts.
- What you can do after
- Build it from scratch with a Dockerfile, then operate and test a web-service-and-database stack with Docker Compose.
Read how Rust Servers, Services, and Apps explains container →
Data Pipelines with Apache Airflow, Second Edition
A Docker container is an isolated runtime instance that packages an application and its dependencies using Docker.
- How it is used
- Runs Airflow services, executes pipeline tasks with their dependencies, and supplies real external systems for tests.
- How deep it goes
- Explains isolation and image-to-container execution, then works through commands, operator configuration, and test fixtures without detailing kernel internals.
- Examples
- Uses a Debian hello-world command, a containerized recommender DAG, recipe preprocessing, and a PostgreSQL-backed operator test.
- What you can do after
- Apply it via Docker, Docker Compose, DockerOperator, and pytest-docker-tools to run tasks or test operators against an external service.
Read how Data Pipelines with Apache Airflow, Second Edition explains container →
Kubernetes for Developers
A container instance is a runtime invocation of a container image that persists as a Docker-managed container until it is removed.
- How it is used
- Positions containers as the isolated application runtime packaged before local Docker use or Kubernetes deployment.
- How deep it goes
- Distinguishes images from runtime instances and walks through starting, stopping, and reconnecting to one; does not examine container internals.
- Examples
- Uses an Ubuntu shell, an in-container Python installation, and Docker commands that revisit a stopped instance.
- What you can do after
- Operate/configure it with Docker by running an image, recognizing the resulting instance, and restarting a stopped container.
Shipping Go: Develop, deliver, discuss, design, and go again
A container is an isolated operating-system-level execution environment that packages an application with its dependencies.
- How it is used
- Packages an application for consistent local use, cross-team sharing, and hosted deployment.
- How deep it goes
- Explains images, runtimes, and the shared host kernel, then walks through building and deployment; defers Kubernetes orchestration.
- Examples
- Uses a Go API built with pack, run with Docker, published through a pipeline, and deployed to Cloud Run.
- What you can do after
- Apply it via Buildpacks and Docker to run a Go application locally, then publish and deploy its image through a pipeline.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains container →
Build Python Web Apps with Streamlit
A Docker container is an isolated runtime environment created from a container image.
- How it is used
- Packages a Streamlit app into a consistent runtime for local testing and cloud deployment.
- How deep it goes
- Works through Dockerfile creation, image building, container startup, port mapping, and mounted files; leaves multi-container PostgreSQL setup aside.
- Examples
- Uses a Streamlit trivia app, a Python-based Dockerfile, build and run commands, and a host-to-container port mapping.
- What you can do after
- Operate/configure it with Docker by building an image, starting a container, and opening the mapped local port.
Read how Build Python Web Apps with Streamlit explains container →
AI Agents in Action, Second Edition
An isolated software execution environment that packages an application with its dependencies while sharing the host operating system kernel.
- How it is used
- Deploys agent APIs as separate services that browser applications or other agents can call.
- How deep it goes
- Works through a Dockerfile, local build and run commands, and Compose orchestration; defers Kubernetes and cloud deployment procedures.
- Examples
- Uses an image-generation API container and a Compose stack containing a web service, image agent, and web agent.
- What you can do after
- Build it from scratch locally with Docker, test the running agent API, and operate a multi-service stack with Compose.
Read how AI Agents in Action, Second Edition explains container →
Machine Learning Platform Engineering
A software container is an isolated, portable execution unit that packages an application with its dependencies.
- How it is used
- Packages applications and dependencies for consistent movement from local development into production environments.
- How deep it goes
- Defines containerization, then walks through a FastAPI app, image building, port mapping, tagging, and registry push.
- Examples
- Uses a FastAPI random-joke service and a containerized YOLOv8 Bento.
- What you can do after
- Build and run a Docker image, map its service port, and push a tagged image to a registry.
Read how Machine Learning Platform Engineering explains container →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A container is an isolated execution environment that packages an application with its dependencies while sharing the host operating system kernel.
- How it is used
- Hosts a microservice locally for testing before its image is published for cluster deployment.
- How deep it goes
- Defines containers, contrasts them with virtual machines and images, then gives commands for running, inspecting, and debugging one.
- Examples
- Uses a video-streaming microservice, a docker run command with port forwarding, container listings, logs, and shell inspection.
- What you can do after
- Operate/configure it with Docker to start a local microservice container, check its output, and inspect problems from inside.
Build and Orchestrator in Go (From Scratch)
A container is an isolated application execution environment that packages software and its dependencies while sharing the host operating system kernel.
- How it is used
- Runs application tasks as portable execution contexts while orchestration hides machine-level infrastructure.
- How deep it goes
- Defines containers through Linux namespaces and cgroups, but defers lower-level mechanics as unnecessary for operating them.
- Examples
- Demonstrates a PostgreSQL container configured with ports and environment variables, queried with psql, inspected, and stopped.
- What you can do after
- Operate/configure Docker containers through run, inspect, and stop commands or equivalent create, start, and stop API calls.
Read how Build and Orchestrator in Go (From Scratch) explains container →
Google Anthos in Action
A containerized application is an application packaged to run inside one or more containers with its required dependencies.
- How it is used
- Modernizes VM workloads, improving deployment speed, portability, resource density, cost efficiency, and operational agility.
- How deep it goes
- Explains migration artifacts, storage, platform delegation, density, and security risks, but does not detail application-specific container construction.
- Examples
- Uses VM migration, Docker images, Dockerfiles, deployment YAML, system containers, and Kubernetes persistent volumes as concrete artifacts.
- What you can do after
- Evaluate and plan VM-to-container migrations with portability, density, storage, operational, and security implications in view.
Tiny CSS Projects
A container is an element that contains and constrains a page's layout content.
- How it is used
- Groups related content for card styling, wide-screen section arrangement, and page-width constraints.
- How deep it goes
- Works through nested HTML and CSS declarations for backgrounds, spacing, flex layout, and maximum width rather than giving an abstract definition.
- Examples
- Uses image-backed cards, a checkout cart and summary, and a newspaper layout on extra-wide screens.
- What you can do after
- Build it from scratch with HTML and CSS to group card content, position checkout sections, and constrain an extra-wide page.
CSS in Depth, Second Edition
A container element in container queries is a specific ancestor element whose size or styles provide the reference for querying a descendant.
- How it is used
- Deploys containers as local responsive references for reusable modules that may appear in columns of different widths.
- How deep it goes
- Explains ancestor selection, explicit size-container definition, querying, nesting, and markup trade-offs without detailing browser internals.
- Examples
- Uses centered page containers, a sidebar media module, nested modules, and a media-body container as concrete examples.
- What you can do after
- Build responsive modules with container-type, container-name, container shorthand, and @container size conditions.
Designing Deep Learning Systems: A guide for software engineers
An isolated runtime instance created from an image that packages an application's code and dependencies.
- How it is used
- Standardizes model-training execution by isolating code and dependencies behind a host service.
- How deep it goes
- Explains packaging, protocol boundaries, launch capacity, environment variables, and lifecycle tracking, but not container internals.
- Examples
- Uses DockerTracker listings, capacity checks, environment-variable injection, queue transitions, and training-container status inspection.
- What you can do after
- Operate a containerized training workflow that launches, parameterizes, monitors, and registers executable code.
Read how Designing Deep Learning Systems: A guide for software engineers explains container →
Spring in Action, Sixth Edition
A containerized application is an application packaged with the files and runtime components needed to run in a container.
- How it is used
- Packages Spring Boot applications for deployment across cloud environments that accept Docker containers.
- How deep it goes
- Explains container portability, Dockerfile lines, image creation, and execution, while stopping short of container runtime internals.
- Examples
- Uses an OpenJDK 11 Dockerfile, Docker build and run commands, and Spring Boot Maven or Gradle image tasks.
- What you can do after
- Build and run a Spring Boot container image with Docker or Spring Boot’s image-building tasks.
Read how Spring in Action, Sixth Edition explains container →
.NET in Action, Second Edition
A container is an isolated execution environment that packages an application with its dependencies while sharing the host operating system kernel.
- How it is used
- Isolate software with specified resources and dependencies to make its runtime environment more portable across machines.
- How deep it goes
- Explains dependency isolation and runtime consistency, then surveys tools; it does not demonstrate building a container image.
- Examples
- Uses a .NET Framework file-path limit change and ASP.NET Core hosted by Kestrel as examples.
- What you can do after
- Evaluate/understand how containers isolate dependencies and preserve a selected .NET runtime across machines with a matching OS.
Read how .NET in Action, Second Edition explains container →
Essential TypeScript 5, Third Edition
A container is an isolated, lightweight execution environment that packages an application with the functionality it needs to run.
- How it is used
- Packages completed web applications for production deployment on platforms that support Docker.
- How deep it goes
- Explains Dockerfile definition, image construction, port mapping, inspection, testing, and stopping, but not deeper container internals.
- Examples
- Demonstrates containerized web, Angular, and React applications using Dockerfiles, build commands, mapped ports, browser tests, and lifecycle commands.
- What you can do after
- Operate/configure a Docker image and container for a prepared Node.js application, including building, running, testing, inspecting, and stopping it.
Read how Essential TypeScript 5, Third Edition explains container →
Go in Practice, Second Edition
A container is an isolated execution unit that packages an application and its required binaries and libraries while sharing a host operating system kernel.
- How it is used
- Deploys Go applications to cloud environments while reducing environmental differences and avoiding unnecessary provider-specific assumptions.
- How deep it goes
- Explains shared-kernel isolation, startup behavior, VM differences, deterministic environments, and a multistage Docker build.
- Examples
- Uses a multistage Dockerfile that compiles a Go executable and copies it into a separate Ubuntu runtime image.
- What you can do after
- Build it from scratch with Docker using separate Go build and runtime stages.
Read how Go in Practice, Second Edition explains container →
Azure Security
A software container is an isolated executable environment that packages an application and its runtime requirements while sharing the host operating system.
- How it is used
- Packages applications for reliable movement across environments and provides a unit for deployment, orchestration, and security monitoring.
- How deep it goes
- Explains images, portability, shared operating systems, orchestration, immutability, and monitoring, but stops short of configuration commands.
- Examples
- Uses shipping containers as an analogy and illustrates multiple containers running on one operating system hosted by a virtual machine.
- What you can do after
- Evaluate container deployments and choose image rebuilding, redeployment, orchestration, and container-aware monitoring practices.
gRPC Microservices in Go
A container is an isolated process environment that packages an application or dependency with its required runtime components.
- How it is used
- Deploys independently scalable microservices and supplies disposable database environments for integration tests.
- How deep it goes
- Explains deployment configuration, service discovery, scaling, readiness checks, and test setup without descending into container internals.
- Examples
- Uses Kubernetes service deployments, a MySQL 8.0.30 Testcontainer, and a Docker Compose database initialized with payments and orders schemas.
- What you can do after
- Apply containers via Kubernetes, Docker Compose, and Testcontainers to deploy services and run database-backed integration tests.
Quarkus in Action
A software container encapsulates an application together with its operating-system environment and dependencies for portable execution.
- How it is used
- Packages applications for portable execution and delegates their lifecycle and resources to Kubernetes during cloud deployment.
- How deep it goes
- Explains packaging, runtime dependencies, pods, and management boundaries, but stops short of detailed Kubernetes internals.
- Examples
- Uses a JVM container containing an application, JVM, and glibc, alongside local Docker and Kubernetes deployment scenarios.
- What you can do after
- Evaluate how applications, runtimes, dependencies, containers, pods, and Kubernetes fit together in a cloud deployment.
Building Distributed Applications that Work
A container is an isolated runtime environment that packages an application with its dependencies while sharing the host operating system kernel.
- How it is used
- Hosts shared infrastructure components, such as identity providers and databases, for Aspire applications.
- How deep it goes
- Defines packaging, isolation, kernel sharing, and Docker images at overview level; defers detailed Docker coverage.
- Examples
- Uses a Keycloak Docker container for single sign-on and a prebuilt Redis integration as contrasting infrastructure examples.
- What you can do after
- Operate/configure it through Aspire app-host methods, extension methods, environment variables, or an external-container connection.
Read how Building Distributed Applications that Work explains container →
Build AI-Enhanced Web Apps
A software container created and run using Docker to isolate an application and its dependencies.
- How it is used
- Supports consistent deployment of AI applications and services across environments.
- How deep it goes
- Explains packaging and orchestration roles but stops short of container internals, configuration, or setup commands.
- Examples
- Uses Docker containers for AI models and associated services, with Kubernetes managing them at scale.
- What you can do after
- Evaluate how Docker packaging and Kubernetes orchestration support consistent, scalable AI-service deployment.
Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
A software construct that packages an application with its dependencies so it can run predictably across different environments.
- How it is used
- Uses containers to automate, reproduce, and scale model training within ML pipelines.
- How deep it goes
- Defines containers and explains dependency packaging, reproducibility, scaling, and artifact access, but defers detailed container technology.
- Examples
- Uses TensorFlow training, a Kuala Lumpur real-estate prediction problem, and Cloud Storage URIs for external artifacts.
- What you can do after
- Operate containerized Vertex AI training by packaging dependencies and supplying artifact locations through environment variables or job arguments.
Read how Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI explains container →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A container is an isolated software execution environment that packages an application with its dependencies.
- How it is used
- Deploys application workloads consistently across local, on-premises, and cloud environments, including AWS services.
- How deep it goes
- Defines the portability and immutability model but deliberately skips Docker image creation and container-starting fundamentals.
- Examples
- Uses a web server and an ALB–ECS–Fargate–S3 architecture as deployment examples.
- What you can do after
- Apply containers to deploy workloads on AWS through App Runner, ECS, or Fargate.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains container →
Related concepts
- container imageproduced by · A container image is a packaged filesystem and configuration artifact from which a container can be created and run.
- Dockerused by · Docker is a platform and ecosystem for building, distributing, and running applications in containers.
- cmd directiveconfigured by · The Dockerfile CMD instruction specifies the default command or arguments executed when a container starts, unless overridden at runtime.
- agent orchestrationused by · Orchestration is the coordination and sequencing of agents, services, tasks, or components to carry out a larger workflow or objective.
- Kubernetesused by · Kubernetes is an open-source platform for orchestrating and automating the deployment, scaling, and management of containerized workloads across computing clusters.
- virtual machinecontrasts with · A virtual machine is a software-based environment that emulates or implements an abstract computer system, providing an interface on which an operating system or programs can execute.
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.