โก Lazy Pulling & P2P Image Distribution
June 12, 2026
๐ก Lazy Pulling แแฟแท P2P Distribution แ nerdctl แแฒแท advanced features แแฝแฑแแซ โ container startup time แแญแฏ แแผแแบแ แฑแแผแฎแธ network bandwidth แแแบแแฌแ แฑแแแบแ
Traditional Image Pulling แแฒแท แแผแฟแแฌ
Traditional approach แแพแฌ container image pull แแฏแแบแแฒแทแกแแซ:
- Image layers แกแแฏแแบแแฏแถแธแแญแฏ download แแฏแแบแแแแบ (GB แแฑแซแแบแธแแปแฌแธแ แฝแฌ)
- Download แแผแฎแธแแพ container start แแฏแแบแแญแฏแทแแแแบ
- Large images แแฝแฑแแพแฌ 5-10 แแญแแ แบ (แแญแฏแท) แแญแฏแแผแฌแแแบ
- Container แ image แแฒแท 10-20% แแฑแฌแแบแแฌ แแแแบ แแฏแถแธแแฑแแแทแบ 100% แแฝแฒแแแแบ
Traditional Flow
docker pull myapp:latest
[========================================] 100%
Layer 1: 200MB โโโโโโโโโโโโ Downloaded
Layer 2: 300MB โโโโโโโโโโโโ Downloaded
Layer 3: 500MB โโโโโโโโโโโโ Downloaded
Total: 1GB downloaded
Time: 5-10 minutes โฐ
Then container starts... ๐
Lazy Pulling แแญแฏแแฌแแฌแแฒ?
Lazy Pulling (stargz-based) แ image layers แแฝแฑแแญแฏ on-demand แแฝแฒแแแบแ Container แ แแญแฏแกแแบแแฒแท files แแฝแฑแแญแฏแแฌ pull แแฏแแบแแผแฎแธ แแปแแบแแฌแแฝแฑแแญแฏ แแฑแฌแแบแแพ (แแญแฏแท) แแฏแถแธแแแแฝแฒแแฐแธแ แแญแฏแธแแพแแบแธแแผแฑแฌแแแบ โ แแแญแฏแกแแบแแฑแธแแฌแแฝแฑ แแแฝแฒแแฐแธแ แแญแฏแแแบ แแฝแฒแแแบ!
Lazy Pulling Flow
nerdctl run --snapshotter=stargz myapp:latest
[===> ] 5% (50MB only!)
Downloading entrypoint + core libraries...
Container starts immediately! ๐โก
Time: 5-10 seconds
(Background: Other files download as needed)
แแแบแแญแฏ แกแแฏแแบแแฏแแบแแฒ?
- stargz format โ Image layers แแญแฏ seekable gzip (stargz) format แแฟแท package แแฏแแบแแฌแธแแแบ
- TOC (Table of Contents) โ Layer แแฒแแพแฌ file แแ แบแแฏแแปแแบแธแ แฎ แแแบแแพแฌแแพแญแแฒ index แแพแญแแแบ
- On-demand fetch โ Container แ file แแ แบแแฏแแญแฏ แแแบแแปแแบแแแบ HTTP range request แแฟแท แแฝแฒแแแบ
- FUSE filesystem โ Remote files แแฝแฑแแญแฏ local filesystem แแญแฏ access แแฏแแบแแญแฏแทแแกแฑแฌแแบ
Lazy Pulling แกแฌแธแแฌแแปแแบแแปแฌแธ
- โก แแปแแบแแผแแบแแแบ โ Container startup 10-30x แแญแฏแแผแแบแแแบ (seconds vs minutes)
- ๐พ Bandwidth แแแบแแฌแแแบ โ แแญแฏแกแแบแแฌแแฌ แแฝแฒแแแบ (50-90% แแปแพแฑแฌแทแแปแแญแฏแแบแแแบ)
- ๐ Auto-scaling แแผแแบแแแบ โ Kubernetes pods แแฝแฑ แแปแแบแแปแแบแธ start แแญแฏแแบแแแบ
- ๐ฐ Cost แแแบแแฌแแแบ โ Registry egress bandwidth charge แแปแพแฑแฌแทแแปแแญแฏแแบแแแบ
แแพแญแฏแแบแธแแพแแบแแปแแบ (1GB Image)
Traditional Pull:
โโ Download: 1GB (100%)
โโ Time: 5-10 minutes
โโ Container starts after download complete
Lazy Pull:
โโ Initial download: 50-100MB (5-10%)
โโ Time: 5-15 seconds
โโ Container starts immediately
โโ Other files fetch on-demand (background)
Use Cases
- CI/CD pipelines โ Test runner containers แแปแแบแแผแแบแ แฝแฌ start
- Kubernetes auto-scaling โ Traffic spike แแผแ แบแแฒแทแกแแซ pods แแผแแบแแผแแบ start
- Large ML models โ 5-10GB images แแฝแฑแแญแฏ แแผแแบแแผแแบ start
- Edge computing โ Bandwidth limited environments
Lazy Pulling Setup & Usage
Prerequisites
- nerdctl installed
- containerd 1.4+ with stargz snapshotter plugin
- Image แ stargz format แแฟแท build แแฏแแบแแฌแธแแแแบ
Install stargz-snapshotter
# Download latest release
wget https://github.com/containerd/stargz-snapshotter/releases/download/v0.15.1/stargz-snapshotter-v0.15.1-linux-amd64.tar.gz
# Extract
tar -C /usr/local/bin -xzf stargz-snapshotter-*.tar.gz
# Start stargz-snapshotter service
systemctl enable --now stargz-snapshotter
# Configure containerd
# Edit /etc/containerd/config.toml
[proxy_plugins]
[proxy_plugins.stargz]
type = "snapshot"
address = "/run/containerd-stargz-grpc/containerd-stargz-grpc.sock"
Build stargz Image
# Method 1: nerdctl build with stargz
nerdctl build -t myapp:stargz --build-arg BUILDKIT_STEP_LOG_MAX_SIZE=-1 .
nerdctl image convert --estargz myapp:stargz myapp:lazy
# Method 2: ctr-remote convert existing image
ctr-remote image convert --estargz docker.io/library/nginx:latest nginx:lazy
# Push to registry
nerdctl push nginx:lazy
Run with Lazy Pulling
# Run container with stargz snapshotter
nerdctl run -d \
--snapshotter=stargz \
-p 8080:80 \
nginx:lazy
# Check startup time
time nerdctl run --rm --snapshotter=stargz nginx:lazy echo "Started!"
P2P Image Distribution แแญแฏแแฌแแฌแแฒ?
P2P (Peer-to-Peer) Distribution แ container images แแฝแฑแแญแฏ centralized registry แแ แบแแฏแแแบแธแแแฑ แแแฝแฒแแฑแฌแทแแฒ network แแฒแ nodes แแฝแฑแแผแฌแธแแพแฌ แแปแพแแฑแแฐแแแบแ BitTorrent แแญแฏ แกแแฏแแบแแฏแแบแแฏแถแแซแแฒแ nerdctl แ IPFS (InterPlanetary File System) แแญแฏ แแฏแถแธแแผแฎแธ P2P distribution support แแฏแแบแแแบแ
Traditional vs P2P
Traditional (Centralized):
Docker Hub / Registry
โฌ๏ธ
โโโโโโโโโโโผโโโโโโโโโโ
โฌ๏ธ โฌ๏ธ โฌ๏ธ
Node1 Node2 Node3
Problem:
โข Registry bandwidth: 1GB ร 100 nodes = 100GB
โข Single point of failure
โข Network bottleneck
P2P (Decentralized):
Docker Hub
โฌ๏ธ 1GB
Node1 (seed)
โฌ๏ธ โฌ๏ธ
Node2 Node3
โฌ๏ธ โ๏ธ โฌ๏ธ
Node4 Node5
Benefits:
โข Registry bandwidth: 1GB only!
โข Nodes share with each other
โข Faster for many nodes
โข No single point of failure
P2P Distribution แกแฌแธแแฌแแปแแบแแปแฌแธ
- ๐ฐ Registry Bandwidth Cost แแปแพแฑแฌแทแแป โ 100 nodes แแญแฏแแแบ 99% bandwidth แแแบแแฌแแแบ
- โก แแผแแบแแแบ โ Parallel downloads from multiple peers
- ๐ Decentralized โ Registry down แแผแ แบแแฒ nodes แแฝแฑ แแปแพแแฑแแญแฏแแบแแฑแธแแแบ
- ๐ Locality-aware โ Same network แแฒแ peers แแแฑ แแญแฏแแผแแบแแแบ
- ๐ Resilient โ Single point of failure แแแพแญ
แแแบแแญแฏ แกแแฏแแบแแฏแแบแแฒ? (IPFS)
- Content Addressing โ Image layers แแญแฏ hash (CID) แแฟแท identify แแฏแแบแแแบ
- DHT (Distributed Hash Table) โ แแแบ node แแพแฌ content แแพแญแแฒ แแพแฌแแแบ
- Peer Discovery โ Network แแฒแ peers แแฝแฑแแญแฏ automatically แแพแฌแแแบ
- Multi-source Download โ Peers แแปแฌแธแ แฝแฌแแแฑ parallel แแฝแฒแแแบ
- Seeding โ Download แแฏแแบแแผแฎแธ node แ content แแญแฏ แแปแพแแฑแแฑแธแแแบ (BitTorrent แแญแฏ)
P2P Use Cases
- Large Kubernetes Clusters โ 100+ nodes แ same image pull แแฏแแบแแฒแทแกแแซ
- CI/CD at Scale โ Multiple runners แ parallel builds
- Edge Computing โ Edge nodes แแฝแฑแ local network แแพแฌ แแปแพแแฑ
- Offline Environments โ Air-gapped networks แแพแฌ local P2P
- Cost Optimization โ Registry egress fees แแปแพแฑแฌแทแแป
Real-World Scenario
Kubernetes cluster: 100 nodes, Image size: 1GB
Traditional:
โโ Registry โ Node 1: 1GB
โโ Registry โ Node 2: 1GB
โโ Registry โ Node 3: 1GB
โโ ... (97 more)
Total registry bandwidth: 100GB
Time: Serial, 5-10 minutes per node
P2P (IPFS):
โโ Registry โ Node 1: 1GB (first node)
โโ Node 1 โ Node 2, 3, 4: Share chunks
โโ Node 2, 3, 4 โ Others: Further sharing
โโ Exponential propagation
Total registry bandwidth: 1GB only!
Time: Parallel, 2-3 minutes for all nodes
๐ฐ Registry egress cost (AWS ECR example): $0.09/GB ร 100GB = $9 vs $0.09 ร 1GB = $0.09 โ 100x savings!
P2P Setup & Usage (IPFS)
Install IPFS
# Install IPFS (kubo)
wget https://dist.ipfs.tech/kubo/v0.25.0/kubo_v0.25.0_linux-amd64.tar.gz
tar -xvzf kubo_*.tar.gz
cd kubo
sudo bash install.sh
# Initialize IPFS
ipfs init
# Start IPFS daemon
ipfs daemon &
# Verify
ipfs version
Configure nerdctl for IPFS
# Install ipfs-registry plugin
wget https://github.com/containerd/nerdctl/releases/download/v1.7.0/nerdctl-full-1.7.0-linux-amd64.tar.gz
# IPFS แ default port 5001 แแพแฌ listen แแฏแแบแแแบ
# nerdctl แ automatic detect แแฏแแบแแแบ
Push Image to IPFS
# Push image to IPFS
nerdctl push ipfs://myapp:latest
# Output:
# Pushed to IPFS: QmXxx... (CID)
# Share this CID with other nodes!
Pull Image from IPFS (P2P)
# Pull from IPFS (automatically finds peers)
nerdctl pull ipfs://QmXxx...
# Or use CID directly
nerdctl run ipfs://QmXxx...
# IPFS automatically:
# 1. Finds peers with this content
# 2. Downloads from multiple peers
# 3. Becomes a seed for other peers
Lazy Pulling + P2P Together ๐
โก Lazy Pulling แแฟแท P2P แแญแฏ แแฝแฒแแฏแถแธแแแบ แกแแฑแฌแแบแธแแฏแถแธ performance แแแแบ โ แแผแแบแแแบแ bandwidth แแแบแแฌแแแบแ scalable แแผแ แบแแแบ! Combined benefits:
- Lazy Pulling โ Container startup seconds แกแแฝแแบแธ
- P2P Distribution โ Registry bandwidth 1% แกแฑแฌแแบ
- Combined โ 100x faster + 99% bandwidth savings!
Example: 1000 Node Cluster
Scenario: Deploy 1GB image to 1000 nodes
Traditional:
โโ Download: 1GB ร 1000 = 1TB
โโ Time: 10 min/node ร 1000 = ~166 hours (serial)
โโ Cost: $0.09/GB ร 1000GB = $90
Lazy + P2P:
โโ Download: ~100MB ร 1 (first node) = 100MB registry
โ Rest: P2P between nodes
โโ Time: 5-10 seconds per node, parallel
โ Total: ~5-10 minutes for all 1000 nodes!
โโ Cost: $0.09/GB ร 0.1GB = $0.009
Result: 100x faster, 10000x cheaper! ๐
Limitations & Considerations
Lazy Pulling Limitations
- Image แ stargz/eStargz format แแผแ แบแแแแบ (rebuild แแญแฏแแแบ)
- Registry แ HTTP range requests support แแฏแแบแแแแบ
- Network latency แแพแญแแแบ on-demand fetch แแพแฑแธแแญแฏแแบแแแบ
- Container แ image แกแแฏแแบ แแฏแถแธแแแบ advantage แแแบแธแแแบ
P2P Distribution Limitations
- IPFS daemon run แแแแบ (extra overhead)
- First node แ registry แแแฑ แแฝแฒแแแแบ (cold start)
- Peers แแแบแธแแแบ performance แแผแแทแบแแพแฌ แแแฏแแบ
- Network firewall rules แแญแฏแกแแบแแญแฏแแบแแแบ (IPFS ports)
- Security: Content verification critical (CID-based)
แแพแแบแแฌแธแแแแทแบ Key Points โญ
- Lazy Pulling โ On-demand image fetch, container startup 10-30x แแผแแบแแแบ
- P2P Distribution โ Peer-to-peer sharing, registry bandwidth 99% แแปแพแฑแฌแทแแปแแญแฏแแบแแแบ
- stargz format โ Seekable gzip, TOC index แแฟแท random access
- IPFS โ Content-addressed, DHT-based P2P network
- Use cases: Large clusters, CI/CD, edge computing, cost optimization
- Combined effect: 100x speed + 99% cost savings!
- Requirements: stargz snapshotter, IPFS daemon, compatible registry
- nerdctl แ Docker แแแพแญแแฒแท features แแฝแฑแแซ โ production-grade alternative
๐ฏ แแแทแบ Thesis แกแแฝแแบ: Multi-cloud orchestration แแพแฌ image distribution optimization แ แกแแฑแธแแผแฎแธแแแบแ Lazy pulling แแฟแท P2P แ cross-cloud deployments แแพแฌ startup time แแฟแท bandwidth cost แแญแฏ แแญแแญแแฌแแฌ แแปแพแฑแฌแทแแปแแฑแธแแญแฏแแบแแแบแ NSGA-II แ placement decide แแฏแแบแแผแฎแธแแแบ nerdctl แ efficient distribution แแฏแแบแแฑแธแแแบ!