Container image
A container image is a packaged filesystem and configuration artifact from which a container can be created and run.
Learn Docker in a Month of Lunches, Second Edition
A container image is a packaged filesystem and metadata bundle containing an application's content, dependencies, and instructions for starting it in a container.
- How it is used
- Packages applications and dependencies for running in containers and sharing across machines.
- How deep it goes
- Works through pulling, Dockerfile builds, layer inspection, cache ordering, multi-stage builds, and size pitfalls.
- Examples
- Uses a Hello World container, a Node.js web-ping image, and a multi-stage Java application image.
- What you can do after
- Build it from scratch with a Dockerfile, then run, inspect, and improve the resulting image using Docker commands.
Read how Learn Docker in a Month of Lunches, Second Edition explains container image →
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
A packaged filesystem and application artifact containing the code, dependencies, and runtime requirements needed to create a container.
- How it is used
- Packages applications for consistent development, testing, deployment, sharing, and composition into microservices.
- How deep it goes
- Explains rootfs, JSON metadata, manifests, layers, transports, runtime conversion, and operational commands, stopping short of full image-building internals.
- Examples
- Uses UBI Apache images, image inspection, layer trees, Containerfiles, registry pushes, and microservice decompositions.
- What you can do after
- Operate/configure images with Podman by pulling, inspecting, running, building, pushing, tagging, comparing, and pruning them.
Road to Kubernetes
A container image is an immutable package containing an application, its dependencies, and the filesystem configuration needed to create a container.
- How it is used
- Packages applications and dependencies for portable local runs, registry sharing, and deployment.
- How deep it goes
- Walks through pulling, building, tagging, running, and pushing images; leaves intricate Dockerfiles and self-hosted registries aside.
- Examples
- Uses an NGINX first run and versioned Python and Node.js images, including a complete Node.js Dockerfile.
- What you can do after
- Build it from scratch with a Dockerfile, then run, tag, and push it using Docker.
Data Pipelines with Apache Airflow, Second Edition
A container image is a packaged filesystem and application specification from which a container can be created.
- How it is used
- Packages task-specific software for containerized Airflow tasks and can carry DAG files or libraries for an Airflow deployment.
- How deep it goes
- Works through Dockerfile construction, building, local testing, and registry-to-worker delivery; does not examine image-format internals.
- Examples
- Uses a weather-command Dockerfile, a ratings-fetching CLI image, and custom Airflow images containing DAGs or dependencies.
- What you can do after
- Build it from scratch with a Dockerfile and docker build, test it with docker run, then reference it from DockerOperator.
Read how Data Pipelines with Apache Airflow, Second Edition explains container image →
Rust Servers, Services, and Apps
A Docker image is an immutable package containing a filesystem, metadata, and application dependencies from which containers can be created.
- How it is used
- Packages a Rust web-service release for container-based testing and deployment.
- How deep it goes
- Works through a basic Dockerfile, build and run commands, then a two-stage build measured by image size.
- Examples
- Uses an Actix Web server, a 1.32 GB basic image, a 31.8 MB runtime image, and a Postgres container.
- What you can do after
- Build it from scratch with a Dockerfile, run and test its container, then reduce its size with a multistage build.
Read how Rust Servers, Services, and Apps explains container image →
Kubernetes in Action, Second Edition
A container image is an immutable package containing a container's filesystem, application, and runtime dependencies from which containers can be created.
- How it is used
- Packages an application and its dependencies for local container runs, registry distribution, and use in a Kubernetes Pod.
- How deep it goes
- Works through running and building images, then identifies shared layers and image reuse without detailing the image file format.
- Examples
- Uses a BusyBox Hello World run, a Node.js application Dockerfile, and a Pod manifest naming an image.
- What you can do after
- Build it from scratch with a Dockerfile and `docker build`, then run or select the image for a container.
Read how Kubernetes in Action, Second Edition explains container image →
Build Python Web Apps with Streamlit
A container image is an immutable package containing an application and the files and metadata needed to create its container runtime.
- How it is used
- Packages a Streamlit app and its dependencies for consistent local and cloud runs.
- How deep it goes
- Works through Dockerfile layers, image building, local containers, port mapping, and secret exclusion; defers multi-container database management.
- Examples
- Uses a Python 3.12 Streamlit Dockerfile, a .dockerignore file, and Docker commands that expose the app at localhost:8502.
- What you can do after
- Build it from scratch with Docker, then run and inspect the image locally before cloud deployment.
Read how Build Python Web Apps with Streamlit explains container image →
.NET in Action, Second Edition
A container image is an immutable package containing an application, its dependencies, and the filesystem data needed to create containers.
- How it is used
- Packages a .NET service for predictable distribution without depending on the host's installed .NET version.
- How deep it goes
- Works through Dockerfile builds, multistage publishing, and CLI publishing, while treating built-in publishing as a basic image that still needs a Dockerfile for customization.
- Examples
- Uses an ASP.NET Core service, Dockerfile and .dockerignore listings, tagged docker build commands, and a dotnet publish command.
- What you can do after
- Build it from scratch with a Dockerfile, or apply it via dotnet publish, then distinguish image settings from runtime configuration.
Read how .NET in Action, Second Edition explains container image →
Shipping Go: Develop, deliver, discuss, design, and go again
A container image is a packaged, immutable filesystem and metadata bundle from which a container can be created.
- How it is used
- Packages a Go service for other teams to pull and run without building it or setting up its language environment.
- How deep it goes
- Explains images as container templates and layered builds, then works through Buildpack and multi-stage Dockerfile choices without detailing image-format internals.
- Examples
- Compares tagged Go application images built with a multi-stage Dockerfile and inspected with `docker images`.
- What you can do after
- Build it from scratch with a Dockerfile, or apply Buildpacks, then publish the image through a tested pipeline.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains container image →
Designing Deep Learning Systems: A guide for software engineers
A Docker image is an immutable package containing filesystem layers and metadata used to create containers.
- How it is used
- Packages training and workflow code for isolated, standard execution by services and Kubernetes-based orchestration.
- How deep it goes
- Explains build, publication, request, pull, launch, and protocol roles without detailing Docker image internals.
- Examples
- Uses PyTorch intent-classification training, a queued Docker job, and a four-step Argo data-processing workflow.
- What you can do after
- Apply it via Docker-based services and Argo templates to run code on workers without manual environment configuration.
Read how Designing Deep Learning Systems: A guide for software engineers explains container image →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A Docker image is an immutable package containing the code, dependencies, assets, and resources needed to instantiate a containerized application or service.
- How it is used
- Packages, publishes, tests, and deploys microservices as repeatable container artifacts.
- How deep it goes
- Defines image contents and immutability, then gives build, tagging, publishing, and deployment steps without exploring image internals.
- Examples
- Uses a Node.js video-streaming microservice, a Dockerfile, versioned command-line builds, registry pushes, and Kubernetes deployment configuration.
- What you can do after
- Build and publish a versioned microservice image, run it as a container, and deploy it through Kubernetes.
Google Anthos in Action
A Docker image is an immutable package containing a filesystem and metadata used to create Docker containers.
- How it is used
- Deploys migrated or newly built applications through registries and Kubernetes-based environments.
- How deep it goes
- Explains image layers, registry workflows, Windows builds, and CI/CD updates without detailing container runtime internals.
- Examples
- Uses CentOS registry commands, generated Linux artifacts, and Windows PowerShell builds targeting GKE.
- What you can do after
- Operate/configure images by tagging, publishing, rebuilding, updating, and deploying them through registry and CI/CD workflows.
GitHub Actions in Action: Continuous integration and delivery for DevOps
A container image is a packaged filesystem and metadata used to create a container execution environment.
- How it is used
- Produces deployable artifacts after quality checks and publishes them for release and continuous delivery.
- How deep it goes
- Explains image creation, scanning, registry publishing, and version-tag substitution without describing image filesystem structure or build internals.
- Examples
- Uses a .NET application, a versioned GitHub Container Registry image, and a Kubernetes Deployment template.
- What you can do after
- Operate/configure image publication and deployment artifacts that point Kubernetes to the exact CI-built image.
Server-Side WebAssembly
A container image is an immutable package containing an application, its dependencies, and the filesystem metadata needed to create a container.
- How it is used
- Contrasts conventional application distribution with Wasm packaging and supports conversion of existing containerized applications.
- How deep it goes
- Explains image contents, architecture and CPU portability, then works through Dockerfile-based building and conversion without container-engine internals.
- Examples
- Uses a Python Flask server built from python:3.9-slim and a Rust Wasm program packaged from scratch.
- What you can do after
- Build it from scratch with a Dockerfile, or apply container2wasm to convert a local image into a runnable Wasm binary.
LLMs in Production
A Docker image is an immutable package containing a filesystem and metadata used to create Docker containers.
- How it is used
- Supplies a ready-to-use software foundation when creating a GPU training VM.
- How deep it goes
- Explains image selection and customization as setup choices, but stops short of detailing image construction.
- Examples
- Uses a Debian 11 Python 3.10 GPU image and gcloud commands for listing and creating instances.
- What you can do after
- Operate GPU VM setup by discovering an image and assigning it during instance creation.
Kubernetes for Developers
A Docker image is an immutable package containing a filesystem, application code, dependencies, and metadata used to create a Docker container.
- How it is used
- Packages an application environment into a repeatable executable artifact for local development and Kubernetes deployment.
- How deep it goes
- Explains image construction through Dockerfiles, dependencies, and runtime instances, while only summarizing multistage builds.
- Examples
- Uses Ubuntu and Python or Ruby images, a Hello Docker script, database clients, fonts, and Docker build-and-run commands.
- What you can do after
- Build it from scratch with a Dockerfile, install dependencies, run the image, and manage resulting local container instances.
Read how Kubernetes for Developers explains container image →
Spring in Action, Sixth Edition
A container image is an immutable package containing an application's filesystem, runtime dependencies, metadata, and startup configuration for creating containers.
- How it is used
- Supports deploying Spring Boot applications to container-based cloud environments, including Kubernetes.
- How deep it goes
- Explains Dockerfile construction, image building, running, naming, and pushing, but stops short of orchestration configuration.
- Examples
- Uses an OpenJDK 11 Dockerfile, a target/*.jar artifact, Docker build and run commands, and Spring Boot image-build tasks.
- What you can do after
- Build it from scratch with Docker or Spring Boot Maven and Gradle tasks, then run, name, and push the resulting image.
Read how Spring in Action, Sixth Edition explains container image →
Build Financial Software with Generative AI (From Scratch)
A Docker image is a read-only package containing the filesystem, application code, and dependencies used to create containers.
- How it is used
- Packages application components and development tools into reusable templates for creating containers in an ACH dashboard project.
- How deep it goes
- Explains read-only templates, Dockerfile instructions, version tags, optimization, and security concerns without descending into image internals.
- Examples
- Uses a Python FastAPI API image, Docker Compose services, Postgres, WSO2 API Manager, and disposable images for exploring technologies.
- What you can do after
- Build it from scratch with a Dockerfile, select a base image and tag, install dependencies, start an API, and remove unnecessary components.
Read how Build Financial Software with Generative AI (From Scratch) explains container image →
gRPC Microservices in Go
A Docker image is a packaged, immutable filesystem and metadata template used to create Docker containers.
- How it is used
- Packages Go gRPC services as deployable Kubernetes artifacts and supplies a MySQL dependency for integration tests.
- How deep it goes
- Works through a multistage Dockerfile, build command, and distribution choices; skips Docker fundamentals.
- Examples
- Uses an Order service Dockerfile and a MySQL 8.0.30 Compose service with database initialization and a health check.
- What you can do after
- Build it from scratch with a service Dockerfile and `docker build`, then prepare the image for Kubernetes deployment.
Read how gRPC Microservices in Go explains container image →
Quarkus in Action
A container image is a packaged filesystem and metadata bundle from which a container can be created and run.
- How it is used
- Packages Quarkus applications into deployable artifacts for containers, registries, local Compose environments, Kubernetes, OpenShift, and serverless platforms.
- How deep it goes
- Explains image variants, Dockerfile instructions, build commands, and runtime choices, but defers exhaustive container installation details.
- Examples
- Uses generated Dockerfiles, a native-micro image, Maven and Docker commands, image listing output, and a containerized native build.
- What you can do after
- Build and run a Quarkus container image with Docker or Podman, including an image based on a container-built native executable.
Akka in Action, Second Edition
A Docker image is an immutable package containing an application, its dependencies, and the metadata needed to create a Docker container.
- How it is used
- Packages an Akka application JAR for Kubernetes deployments and pod creation.
- How deep it goes
- Walks through plugin settings, ports, local publishing, registry tagging, pushing, and deployment use without detailing image internals.
- Examples
- Uses a minimal Java 11 image setup and a betting-house image exposing management, remote, service, and projection ports.
- What you can do after
- Operate/configure it by building, tagging, publishing, and referencing an application image in a Kubernetes deployment.
Read how Akka in Action, Second Edition explains container image →
Essential TypeScript 5, Third Edition
A Docker image is an immutable package containing the files, metadata, and configuration needed to create a Docker container.
- How it is used
- Packages a compiled web application and its deployment dependencies into a portable artifact for platforms that support Docker.
- How deep it goes
- Explains image construction through Dockerfile instructions, file exclusion, dependency installation, execution, and stopping, without detailing image internals.
- Examples
- Uses webapp, Angular, and React application images with Dockerfiles, build commands, port mappings, and browser tests.
- What you can do after
- Operate/configure Docker to build a named image, run it as a container, test its mapped port, list containers, and stop execution.
Read how Essential TypeScript 5, Third Edition explains container image →
Just Use Postgres!
A container image is an immutable package containing a filesystem and configuration from which an isolated container runtime is created.
- How it is used
- Runs PostgreSQL with a selected extension for vector search or time-series application development.
- How deep it goes
- Demonstrates image selection, container startup, volumes, ports, and extension checks, while deferring production security and deployment practices.
- Examples
- Uses pgvector and TimescaleDB images, Docker run commands, psql connections, and extension-version queries.
- What you can do after
- Operate/configure PostgreSQL containers by selecting an extension image, mapping port 5432, mounting a volume, and verifying availability.
Machine Learning Platform Engineering
A Docker image is a packaged, executable filesystem containing an application and its dependencies for creating containers.
- How it is used
- Packages applications and ML notebook environments for reproducible deployment and execution.
- How deep it goes
- Explains construction, tagging, execution, registry storage, and notebook-image layers without detailing Dockerfile instructions.
- Examples
- Uses hello-joker commands, port mapping, registry pushes, and custom Kubeflow notebook layers.
- What you can do after
- Build and run tagged Docker images, publish them to registries, and configure custom Kubeflow notebook images.
Read how Machine Learning Platform Engineering explains container image →
Software Security for Developers
A container image is an immutable package containing an application and the files, metadata, and runtime components needed to execute it in a container.
- How it is used
- Packages applications securely for developer-managed deployment and execution on Kubernetes.
- How deep it goes
- Identifies insecure image examples and points to Dockerfiles and cloud-native buildpacks, without detailing image-building procedures.
- Examples
- Uses Dockerfiles, cloud-native buildpacks, secure Kubernetes clusters, and deployment manifests as practical artifacts.
- What you can do after
- Build secure container images and pair them with Kubernetes manifests that follow security best practices.
Read how Software Security for Developers explains container image →
Related concepts
- Dockerfileproduced by · A Dockerfile is a text file containing declarative instructions for building a container image and specifying its contents and runtime metadata.
- containerproduces · A software container is an isolated execution environment that packages an application and its dependencies while sharing the host operating system kernel.
- image layerhas part · An image layer is an immutable filesystem change set that contributes to a layered container image and may be stored, cached, or shared independently.
- docker buildproduced by · docker build is a Docker command that constructs a container image from a Dockerfile and its build context.
- from instructionused by · The FROM instruction is a Dockerfile directive that selects the base image or empty filesystem for a container image build stage.
- dependency managementaddresses · Dependency management is the practice of declaring, resolving, versioning, obtaining, updating, and controlling the software components required by a project.
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.