docker-library/official-images

Features

• Base Images - Provides a curated collection of standardized base images following industry best practices for reliability and security.
• OCI Container Engines - Provides curated base images that adhere to Open Container Initiative standards for portability.
• Automated Image Build Pipelines - Provides an automated pipeline for building, tagging, and pushing images to ensure current dependencies and security patches.
• Startup Arguments - Configures the default executables and parameters passed during container initialization.
• Container Build Specifications - Defines the container environment and startup behavior using declarative Dockerfile specifications.
• Container Build Stages - Initializes container build environments and manages the layering of base images.
• Container Command Execution - Executes shell commands and binaries within a controlled environment to create new image layers during builds.
• Container Configuration - Defines container runtime behavior through the configuration of entrypoints, environment variables, and health checks.
• Container Entrypoint Execution - Configures the primary executable entrypoint so containers function as dedicated command-line tools.
• Multi-Architecture Images - Uses image indexes to map single tags to multiple platform-specific digests for cross-platform execution.
• Image Stream Lifecycles - Manages the lifecycle of image tags and updates based on base image changes through centralized definitions.
• Container Images - Serves as a central repository of official container images adhering to OCI standards for portability.
• Executable Configurations - Defines the primary binary and default startup arguments to ensure consistent container execution.
• Container Default Commands - Defines the default commands and arguments for containers to ensure consistent startup behavior.
• Language Base Images - Provides a curated collection of standardized base images that serve as trusted foundations for other containers.
• Multi-Stage Build Pipelines - Separates build-time environments from runtime outputs to minimize the final image footprint.
• Image Build Optimizations - Employs multi-stage builds and layer caching to reduce image footprints and improve build speeds.
• Multi-Architecture Manifests - Supports cross-platform distribution by mapping a single image tag to multiple hardware architectures.
• Container User Defaults - Specifies the default username or UID for build instructions and the final container runtime environment.
• Context-Aware File Copying - Copies files and directories from the local build context or remote URLs into the image filesystem.
• Curated Base Image Collections - Maintains a standardized collection of curated Docker base images for building containerized applications.
• Layered Filesystems - Builds images using a stack of immutable read-only layers for efficient filesystem composition.
• Multi-Architecture Image Indexes - Distributes a single image tag across multiple hardware platforms using image indexes.
• Runtime Environment Configuration - Sets environment variables and updates system paths to ensure software runs correctly across environments.
• Runtime User Overrides - Allows specifying the username or UID used to execute the container's primary process for security isolation.
• Image Pipeline Automation - Automates the cloning, building, tagging, and pushing of images to a registry.
• System Call Surface Minimizers - Limits the kernel system call interface using security profiles to minimize the container's attack surface.
• Non-Root Process Identities - Reduces the attack surface by assigning non-root users and groups to the container process.
• Linux Capability Management - Provides fine-grained control over kernel privileges and device access to harden container security.
• Container Security Hardening - Harden containers by restricting process privileges, managing Linux capabilities, and enforcing non-root users.
• Container Privilege Restrictions - Implements non-root user configurations to reduce the host attack surface by restricting process privileges.
• Environment Variables - Defines persistent environment variables and system paths to configure software behavior across container runs.
• Data Persistence - Manages persistent data by exposing specific directories as volumes for mutable user files.
• Volume Mounts - Defines volume mount points to persist mutable data outside the immutable image layers.
• Build Configuration Arguments - Supports passing dynamic arguments during the build process that do not persist in the final image.
• Container Asset Importers - Provides capabilities to import local files or remote artifacts directly into the image filesystem.
• Container Image Metadata - Provides a way to attach custom key-value labels for licensing, ownership, and automation metadata to images.
• Container Image Templates - Provides a library of best-practice image configurations and base images to automate software environment builds.
• Container Port Mappings - Configures the network ports on which a container listens to facilitate external traffic mapping.
• Container Storage Persistence - Uses volume and bind mounts to ensure data durability on the host system across container restarts.
• Triggered Build Steps - Includes instructions that execute automatically when an image is used as a base for a new build.
• Environment Variables - Define variables that persist across build stages and remain available during container runtime.
• Inherited Build Triggers - Provides mechanisms to trigger specific build steps automatically when an image is used as a base for others.
• Build Result Caching - Implements build-cache reuse to avoid redundant processing during subsequent image builds.
• Build Performance Optimization - Accelerates the development cycle by leveraging build caches to reuse unchanged instructions.
• Build Context Optimization - Uses configuration files to exclude irrelevant local data from the build context to optimize performance.
• Container Monitoring Tools - Defines health check commands and intervals to monitor and report the operational status of containers.
• Health Checks - Executes periodic commands within the container to report the operational status of internal services.

Star history