Container Images
Container images are read-only templates containing an application's filesystem, libraries, and configuration, layered and stored as distributable artifacts. Understanding how images are built, stored in registries, and layered is essential to efficient container workflows.
itVirtualization, containers, and orchestration | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Container Images
A container image is a prepared application environment: files plus instructions for starting them. Before images, keeping two machines ready for the same release meant repeated installations and hopeful comparison of libraries, certificates, and settings. An image makes that environment one named thing to build, test, store, copy, and deploy. The host still supplies the kernel, because an image is not a tiny operating system in a trench coat.
The first useful distinction is image versus container. The image is stored content and runtime defaults. A container is one running instance made from it. One image can create many containers, each with different runtime settings and writable state. A registry is the delivery warehouse between build and runtime, holding the manifests and blobs that clients push and pull.
The central paperwork is the image manifest. It points to configuration and an ordered list of layers. A layer is a filesystem changeset, so later layers can add, modify, or hide paths from earlier ones. Hiding is not erasing, which is an awkward fact with excellent timing: a secret copied into an earlier layer remains in that blob even if a later step removes the file. Keep secrets out of the build context and layers.
A tag is the label people recognize, such as a release channel. It can move. A digest identifies exact bytes and changes when those bytes change. That makes a tag useful for communication and a resolved digest useful for approval or audit. Neither proves the publisher, freshness, or safe behavior. Those questions need separate evidence, because images decline to solve every operational problem merely by being neatly packaged.
Read the intro and cheatsheet for the manifest, configuration, layers, descriptor, and image index. The slides compress the delivery path and tag-versus-digest choice. The practice reference gives local inspection commands, and the exercise makes you inspect a two-stage image and multi-platform index. Then follow the reference links into provenance, signing, vulnerability management, and deployment policy.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://specs.opencontainers.org/image-spec/
Supports
- OCI image goals and standard object model
- Image manifests, configuration, layers, descriptors, and indexes
- https://github.com/opencontainers/image-spec/blob/main/manifest.md
Supports
- Image manifest schema
- Configuration and ordered layer descriptors
- https://github.com/opencontainers/image-spec/blob/main/config.md
Supports
- Image execution parameters and platform fields
- Root filesystem layer identities and runtime defaults
- https://github.com/opencontainers/image-spec/blob/main/layer.md
Supports
- Filesystem changesets and ordered application
- Additions, modifications, removals, and whiteout behavior
- https://github.com/opencontainers/image-spec/blob/main/image-index.md
Supports
- Image indexes and manifest descriptors
- Operating system, architecture, and platform variant selection
- https://github.com/opencontainers/image-spec/blob/main/descriptor.md
Supports
- Descriptor media type, size, and digest fields
- Content addressability and independent digest verification
- https://github.com/opencontainers/distribution-spec/blob/main/spec.md
Supports
- Registry, repository, manifest, blob, tag, push, and pull definitions
- Standard content distribution and discovery API model
- https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-an-image/
Supports
- Beginner image, immutability, and layer mental model
- Relationship between image packages and running containers
- https://docs.docker.com/get-started/docker-concepts/building-images/build-tag-and-publish-an-image/
Supports
- Image reference structure
- Build, tag, history inspection, and registry push workflow
- https://docs.docker.com/build/building/best-practices/
Supports
- Base image selection, minimal packages, build context exclusions, and cache use
- Regular rebuilds, mutable tags, digest pins, and continuous testing
- Multi-stage build guidance and secret-handling cautions
- https://docs.docker.com/build/building/multi-stage/
Supports
- Multiple build stages
- Copying selected artifacts into a focused final image
- https://docs.docker.com/build/building/multi-platform/
Supports
- Single-platform and multi-platform image structure
- Image index selection and platform build strategies
- https://csrc.nist.gov/pubs/sp/800/190/final
Supports
- Image and registry risks in the container threat model
- Image vulnerability, trust, configuration, and lifecycle concerns
- https://www.docker.com/blog/docker-open-sourced/
Supports
- Docker open-source release in 2013
- https://opencontainers.org/posts/announcements/2017-07-17-open-container-initiative-oci-releases-v1-0-of-container-standards/
Supports
- OCI formation in 2015
- OCI Image Specification v1.0 release in 2017
- https://opencontainers.org/posts/blog/2018-10-11-oci-image-support-comes-to-open-source-docker-registry/
Supports
- OCI image-spec origins and Docker distribution OCI support
- https://github.com/opencontainers/distribution-spec/releases/tag/v1.0.0
Supports
- OCI Distribution Specification v1.0 release in 2021
- https://opencontainers.org/posts/blog/2023-07-07-summary-of-upcoming-changes-in-oci-image-and-distribution-specs-v-1-1/
Supports
- Planned OCI Image and Distribution v1.1 changes
- https://opencontainers.org/posts/blog/2024-03-13-oci-image-and-distribution-specs-v1-1-releases/
Supports
- OCI Image and Distribution Specification v1.1 release in 2024
