moby/buildkit

Features

• Container Image Builders - Functions as a programmable OCI-compliant builder that assembles filesystem layers into distributable images.
• OCI Container Engines - Implements an OCI-compliant engine for building and distributing container images.
• Graph Definitions - Provides a programmable client for defining build processes as protobuf-based dependency graphs.
• Build Orchestrators - Orchestrates the build process by generating a binary definition that manages operations and concurrency.
• Cross-Platform Build Targets - Manages the hardware architectures and operating systems supported by the build engine for multi-platform image creation.
• Distributed Layer Cache Managers - Manages a distributed cache of intermediate image layers across registries and cloud storage to accelerate builds.
• Build Execution Engines - Acts as a build execution engine that runs commands and scripts within containerized environments.
• Build Pipelines - Structures build operations as an automated pipeline to manage complex dependencies and execution sequences.
• Build Execution Backends - Implements the backend execution layer that processes build dependency graphs into actual container image layers.
• Container Build Orchestrators - Functions as a centralized build infrastructure that can be hosted remotely via TCP or Kubernetes.
• Container Build Tools - Provides a comprehensive toolkit for defining build graphs and executing containerized processes across architectures.
• Container Command Execution - Executes build commands inside containers with custom arguments, environment variables, and user permissions.
• Image Generation - Provides a programmable engine to execute build processes and generate OCI container images.
• Container Image Registry Uploads - Pushes built images to remote registries with configurable compression and metadata.
• Build Layer Caching - Accelerates build cycles by storing and retrieving intermediate image layers across registries or cloud storage.
• Multi-Architecture Images - Generates container images compatible with multiple CPU architectures and operating systems in a single process.
• Build - Uses a low-level binary intermediate representation (LLB) to separate build definitions from the execution engine.
• Directed Acyclic Graph Engines - Models the build process as a directed acyclic graph to execute independent operations concurrently.
• Content-Addressable Caches - Implements a content-addressable cache to store and retrieve intermediate build layers based on input hashes.
• Distributed Caches - Uses consistent hashing to distribute build tasks across cluster nodes and maximize local cache reuse.
• Build-Time Mounts - Manages various mount types including bind, secret, SSH, and cache mounts for build processes.
• Cache Integrity Verification - Validates the integrity of remote caches using signatures and timestamp thresholds.
• Version Pinning Tools - Constrains external images and sources to specific versions to maintain build consistency and reproducibility.
• Deterministic Build Metadata - Ensures reproducible builds by setting constant Unix timestamps for image metadata.
• Container Engine Configurations - Configures the runtime shim and operational behavior of the underlying container engine used during image construction.
• Intermediate Representation Translators - Converts standard Dockerfile instructions into a low-level binary intermediate representation for precise build execution.
• Image Assembly Stabilization - Stabilizes image layer assembly logic to ensure consistent outputs regardless of the build engine version.
• In-Cluster Build Daemons - Operates as a container-native build engine deployed within Kubernetes for scalable image construction.
• Kubernetes Deployments - Enables the deployment of the build engine as a scalable workload within Kubernetes clusters.
• gRPC Interfaces - Utilizes gRPC interfaces for high-performance communication between the build client and the daemon.
• User-Mode Emulation - Employs user-mode emulation to run binaries for foreign CPU architectures during multi-platform builds.
• Build Provenance Attestors - Stores build definition parameters and provenance data to ensure supply chain transparency.
• Non-Root Container Execution Environments - Provides a rootless execution mode that runs the build daemon under a standard user account to enhance security.
• Mutual TLS Transports - Secures traffic between the build client and daemon using mutual TLS certificates.
• Transport Layer Security - Secures communication between clients and the build daemon using mutual TLS certificates.
• Cache Garbage Collection - Manages disk usage by setting space limits and retention durations for cached image layers and build artifacts.
• Consistent Hashing - Uses consistent hashing to route build requests to specific daemons, maximizing local cache reuse.
• Reproducible Builds - Ensures bit-for-bit identical image outputs by standardizing timestamps and pinning dependency versions.
• TCP Listeners - Exposes the build engine via a secure TCP listener to allow remote clients to trigger builds.
• Build Performance Metrics - Records timing and logs of individual build steps into trace files for performance analysis.
• Cache Hit Optimizations - Optimizes cache hit rates by merging copy chains and handling git sources directly.
• Image Builders - Concurrent and cache-efficient builder toolkit.

Istoric stele