image
A read-only package containing a program and everything it needs to run, used as the template for containers.
In more detail
An image is built once and can run as many identical containers. It is identified by a name and tag for people and by a digest for its exact bytes.
Examples
In this course the image is the release unit: built once, tagged with the commit, pushed to a registry and promoted unchanged by its digest.In AWS: A read-only package that holds the files, libraries and settings a container starts from.redpandadata/redpanda:v25.2.6postgres:16-alpineA container image is one way to package application bytes and their dependencies as an artifact. Build it once, identify it by digest, and inject configuration and secrets at deployment rather than baking them in.A JDK image builds the JAR; a smaller JRE image runs it.In this course: Pin the exact image version a test uses, so everyone gets the same database version and the test cannot change underneath you. The same image gives every developer and every pipeline run the same dependency.Related terms
- digest — A SHA-256 hash of an image's manifest that identifies its exact content and can never be moved to other bytes.
- tag — A human-readable label such as 3.20 or latest attached to an image in a repository, which can be moved to point at a different image.
- registry — A server that stores images and lets clients push and pull them by name, tag or digest.
- image promotion — Moving the exact same, already-tested image through environments, such as staging to production, without rebuilding it.
- container — A running program that has been fenced off from the rest of the computer so it only sees its own files, network and processes.
- Amazon ECR — Amazon Elastic Container Registry, the AWS service that stores container images for ECS, EKS and other services to pull.
- Dockerfile — A text file of instructions, such as FROM, COPY and RUN, that tells Docker how to build an image.
- docker build — The command that builds an image from a Dockerfile and a build context.
- artifact — A file produced by a build, such as a compiled program or an image, that is stored and passed on to later steps.
- layer — One read-only slice of an image that records the files a single build step added, changed or deleted.
- multi-stage build — A Dockerfile with several FROM stages, where later stages copy only what they need from earlier ones.
- minimal base image — A base image with as little inside as possible, such as Alpine, a slim variant or a distroless image, to shrink size and attack surface.
- base image — The image a Dockerfile starts from with FROM, which supplies the operating system files and often a language runtime.
- image scanning — Checking the packages inside an image against lists of known vulnerabilities.
- pinning — Fixing an exact version or digest of something you depend on so it cannot change without you noticing.
Taught in
- Building and Pushing Container Images — Continuous Integration & Continuous Delivery Pipelines
- Artifact Promotion: Staging to Production — Continuous Integration & Continuous Delivery Pipelines
- What is GitOps? — Continuous Integration & Continuous Delivery Pipelines
- Running, And Still Down — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Two Hours, Twenty Tasks: Exam Strategy — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Container Images The Exam Way — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Choose The Right Workload Resource — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Sidecars And Init Containers — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Persistent And Ephemeral Volumes — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Design And Build: Timed Drill And Checkpoint — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Rolling Updates And Rollbacks — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Blue/Green With Labels And A Service — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Canary Releases From Replica Counts — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Helm: Install, Upgrade And Roll Back — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Kustomize Bases, Overlays And Patches — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Deployment: Timed Drill And Checkpoint — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Probes And Health Checks — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Monitoring With The Built-in CLI — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Debugging Applications In Kubernetes — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Observability: Timed Drill And Checkpoint — Certified Kubernetes Application Developer (CKAD) Exam Prep
- ConfigMaps And Secrets — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Requests, Limits And Quotas — Certified Kubernetes Application Developer (CKAD) Exam Prep
- ServiceAccounts And Tokens — Certified Kubernetes Application Developer (CKAD) Exam Prep
- SecurityContexts And Capabilities — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Configuration And Security: Timed Drill And Checkpoint — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Mock Exam: Sixteen Tasks Against The Clock — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Final Review: Where Your Marks Are At Risk — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Elasticity and Scale — Cloud Infrastructure & Hyperscaler Architecture
- Elastic Compute Cloud (EC2) — Cloud Infrastructure & Hyperscaler Architecture
- Containers on AWS (ECS and EKS) — Cloud Infrastructure & Hyperscaler Architecture
- Comparing Compute Options — Cloud Infrastructure & Hyperscaler Architecture
- Auto Scaling Groups — Cloud Infrastructure & Hyperscaler Architecture
- Object, Block, and File Storage — Cloud Infrastructure & Hyperscaler Architecture
- S3: Buckets and Objects — Cloud Infrastructure & Hyperscaler Architecture
- Shared Responsibility Model & Cloud Threat Landscapes — Cloud Security & DevSecOps Engineering
- Cloud IAM Architecture & Permission Boundaries — Cloud Security & DevSecOps Engineering
- Software Composition Analysis with Trivy — Cloud Security & DevSecOps Engineering
- Supply Chain Security: SBOMs & Cosign Signing — Cloud Security & DevSecOps Engineering
- Container Hardening: Distroless & Rootless — Cloud Security & DevSecOps Engineering
- Kubernetes Pod Security Standards: Baseline & Restricted — Cloud Security & DevSecOps Engineering
- Runtime Anomaly Detection with Falco & eBPF — Cloud Security & DevSecOps Engineering
- Enforcing OPA Guardrails on Terraform Plan Payloads — Cloud Security & DevSecOps Engineering
- Green Tests, Red Production — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Codebase And Dependencies — DevOps & Site Reliability Engineering
- Containers And Orchestration Context — DevOps & Site Reliability Engineering
- Union Filesystems, Images And Writable Layers — Docker Architecture & Production Containers
- Docker, OCI, The Engine And The CLI — Docker Architecture & Production Containers
- Pull And Inspect A Third Party Image — Docker Architecture & Production Containers
- Run, Stop, Restart And Remove A Container — Docker Architecture & Production Containers
- Run The Spine Service And Publish Its Port — Docker Architecture & Production Containers
- Build Context, Dockerignore And Your First Dockerfile — Docker Architecture & Production Containers
- FROM, WORKDIR, COPY And ADD — Docker Architecture & Production Containers
- RUN, SHELL And Efficient Layer Caching — Docker Architecture & Production Containers
- ARG, ENV, LABEL, EXPOSE And VOLUME — Docker Architecture & Production Containers
- CMD, ENTRYPOINT, USER And Process Signals — Docker Architecture & Production Containers
- Multi Stage Builds, Targets And Build Secrets — Docker Architecture & Production Containers
- Tags, Digests And Reproducible Image References — Docker Architecture & Production Containers
- Authenticate, Tag, Push And Pull From A Registry — Docker Architecture & Production Containers
- Minimal Bases, Non Root Users And Smaller Images — Docker Architecture & Production Containers
- Scan, Patch And Inspect The Software Supply Chain — Docker Architecture & Production Containers
- Ephemeral Filesystems And Named Volumes — Docker Architecture & Production Containers
- Bind Mounts, Permissions And Backups — Docker Architecture & Production Containers
- Bridge Networks, DNS And Container Communication — Docker Architecture & Production Containers
- Port Publishing, Localhost And Network Troubleshooting — Docker Architecture & Production Containers
- Environment, Secret Files And Runtime Restrictions — Docker Architecture & Production Containers
- Define The Service And Database With Compose — Docker Architecture & Production Containers
- Health Checks, Dependencies And Reliable Startup — Docker Architecture & Production Containers
- Development Overrides, Hot Reloading And Debuggers — Docker Architecture & Production Containers
- Integration Tests, Test Data And Compose Cleanup — Docker Architecture & Production Containers
- Diagnose Crashes, Resource Limits And Unhealthy Containers — Docker Architecture & Production Containers
- Build, Test And Promote The Same Image In CI — Docker Architecture & Production Containers
- Harden And Deliver The Complete Service Stack — Docker Architecture & Production Containers
- From Local Containers To Kubernetes — Docker Architecture & Production Containers
- OpenTelemetry, Container Publishing and Trimming — Modern .NET Core, C# & Enterprise Microservices
- Containerization Architecture: Multi-Stage Dockerfiles — Production Full-Stack Engineering
- What Go Is and Why It Matters — Concurrent Systems Programming with Go
- Installing the Go Toolchain — Concurrent Systems Programming with Go
- Your First Program and go run — Concurrent Systems Programming with Go
- Files and the os Package — Concurrent Systems Programming with Go
- Parsing Arguments with flag — Concurrent Systems Programming with Go
- Building Static Binaries — Concurrent Systems Programming with Go
- Shipping in Scratch and Distroless Images — Concurrent Systems Programming with Go
- Containerizing and Testing the Final Build — Concurrent Systems Programming with Go
- The Virtual Machine, The Kit And The Runtime — Modern Java: Virtual Threads & High-Throughput Services
- Packaging Into A Container — Modern Java: Virtual Threads & High-Throughput Services
- Why A Log And Not A Queue — Apache Kafka & Event Streaming
- A Producer In Python — Apache Kafka & Event Streaming
- From Docker To Desired State — Kubernetes: Production-Grade Container Orchestration
- Worker Nodes: kubelet, Runtime, CNI And kube-proxy — Kubernetes: Production-Grade Container Orchestration
- Bootstrap A Local Cluster And Check Your Context — Kubernetes: Production-Grade Container Orchestration
- Namespaces, Labels And Declarative Manifests — Kubernetes: Production-Grade Container Orchestration
- Pods, Init Containers And Sidecars — Kubernetes: Production-Grade Container Orchestration
- Deployments, ReplicaSets, Rollouts And Rollback — Kubernetes: Production-Grade Container Orchestration
- DaemonSets And Node Services — Kubernetes: Production-Grade Container Orchestration
- Jobs And CronJobs — Kubernetes: Production-Grade Container Orchestration
- Production Hardening: Graceful Shutdown & Docker — Node.js Internals & Backend Services
- Why Secrets Leak — Application Security & Threat Modeling for Engineers
- Software Bill Of Materials — Application Security & Threat Modeling for Engineers
- Container Security: Minimal Bases And Non Root — Application Security & Threat Modeling for Engineers
- Image Scanning And Trivy — Application Security & Threat Modeling for Engineers
- Integration Testing With Containers — Automated Testing, TDD & Quality Engineering