IPFS Deployment

BY | Jun 15, 2026 | Apps and Dapps

Node.js + IPFS Deployment Examples: Docker, Kubernetes, Kubo, Helia & Elastic Setups

Running IPFS alongside Node.js applications is becoming increasingly popular for building decentralized apps (dApps), content platforms, and scalable backends. In this post we’ll look at practical deployment patterns using Docker and Kubernetes with the two main IPFS implementations: Kubo (Go) and Helia (JavaScript-native), plus guidance on building elastic, auto-scaling setups using Elastic-IPFS.

Quick Feature Comparison

┌──────────────────┬────────────────┬───────────────┬─────────────────┐
│ Feature          │ Kubo (Go)      │ Helia (JS)    │ Elastic-IPFS     │
├──────────────────┼────────────────┼───────────────┼─────────────────┤
│ Architecture     │ Separate daemon│ In-process    │ Hybrid (K8s)     │
│ Language         │ Go             │ JavaScript    │ Multi-language   │
│ Setup Complexity │ Medium         │ Low           │ High             │
│ Auto-scaling     │ Manual/Pool    │ Via HPA       │ Native (K8s)     │
│ Best for         │ Heavy pinners  │ Microservices │ Production dApps │
└──────────────────┴────────────────┴───────────────┴─────────────────┘

Implementation Deep Dive

Kubo (Go IPFS)

The original and most mature IPFS implementation. Runs as a separate daemon. Excellent for dedicated IPFS nodes, pinning services, and when you need maximum compatibility and performance.


Kubo GitHub

Helia (JS IPFS)

Modern, lightweight, and runs inside your Node.js process. No separate daemon needed. Ideal for microservices, serverless-style deployments, and when you want tight integration with your application code.


Helia Official

Elastic-IPFS

A modern approach combining IPFS with Kubernetes native scaling. Uses Helia for app-layer embedding + Kubo clusters for persistence. Automatically scales with HPA and content demand.


Elastic-IPFS Docs

Docker Deployment Examples

Kubo + Node.js (Separate Containers)

Best when you want a dedicated IPFS node that multiple services can use. Kubo daemon runs independently.
version: '3.8'
services:
  ipfs:
    image: ipfs/kubo:latest
    volumes:
      - ipfs-data:/data/ipfs
    ports:
      - "4001:4001"
      - "5001:5001"
      - "8080:8080"

  app:
    build: .
    depends_on:
      - ipfs
    environment:
      - IPFS_API_URL=http://ipfs:5001

Helia (Embedded in Node.js)

Best for lightweight, single-container deployments. Helia runs inside your Node.js app — no extra daemon needed.
# Dockerfile
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
CMD ["node", "index.js"]
Initialize Helia directly in your code:
import { createHelia } from 'helia'
import { unixfs } from '@helia/unixfs'

const helia = await createHelia()
const fs = unixfs(helia)
// Add/retrieve files directly in your app

Elastic-IPFS Node

A self-contained elastic node that auto-registers with your Kubernetes cluster. Ideal for dynamic scaling environments.
version: '3.8'
services:
  elastic-ipfs:
    image: elasticipfs/node:latest
    environment:
      - CLUSTER_MODE=auto
      - REPLICATION_FACTOR=3
    volumes:
      - elastic-data:/data/ipfs
    ports:
      - "4001:4001"
      - "5001:5001"

Kubernetes Deployment Examples

Kubo in Kubernetes (StatefulSet)

Recommended when you need persistent, highly available IPFS nodes with stable network identity and persistent storage.
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: ipfs-kubo
spec:
  serviceName: ipfs
  replicas: 3
  template:
    spec:
      containers:
      - name: ipfs
        image: ipfs/kubo:latest
        volumeMounts:
        - name: data
          mountPath: /data/ipfs
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 100Gi

Helia in Kubernetes (Deployment)

Best for stateless or easily scalable application pods that embed IPFS functionality directly in the app.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ipfs-helia-app
spec:
  replicas: 5
  template:
    spec:
      containers:
      - name: app
        image: your-app:latest
        env:
        - name: HELIA_LIBP2P_LISTEN
          value: "/ip4/0.0.0.0/tcp/4001"

Elastic-IPFS (Auto-Scaling)

Combines IPFS Cluster with HPA for automatic scaling based on storage demand and request load.
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: elastic-ipfs
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: StatefulSet
    name: ipfs-cluster
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: storage
      target:
        type: Utilization
        averageUtilization: 70

Elastic-IPFS Auto-Scaling Patterns

Horizontal Scaling

Use K8s HPA on Helia-based Deployments. New pods automatically discover peers via libp2p and share content load.

Storage Scaling

Combine IPFS Cluster with auto-scaling node pools. Add/remove storage capacity on demand without downtime.

Content Routing

Implement content-based routing with caching layers. Use Cloudflare or self-hosted gateways for high-traffic paths.

Tiered Storage

Use S3-compatible object storage as cold layer + IPFS as hot tier for frequently accessed content.

Predictive Scaling

Analyze content access patterns to pre-scale nodes before demand spikes. Ideal for NFT drops or content releases.

Recommended Architecture

Helia inside microservices (app logic) + Kubo/IPFS Cluster (persistent layer) + Gateway/CDN (edge caching).

Deployment Recommendations by Scale

Small / Homelab

Use Docker Compose with Helia embedded in your app. Simplest setup, single node, good for learning and small projects.

Medium Production

Kubo + IPFS Cluster on Kubernetes with 3+ replicas. Balanced between reliability and operational complexity.

Large Scale / Elastic

Helia in auto-scaling Deployments + Kubo/IPFS Cluster as managed pinning layer + CDN/gateway fronting for global performance.

Official Resources & Documentation

Questions for the Community

Are you running IPFS with Node.js in Docker or Kubernetes?

Share your deployment architecture below!

Do you prefer Kubo or Helia for your use case?

What factors influenced your choice?

Have you implemented elastic/auto-scaling with IPFS?

What challenges did you face?

Disclaimer

This content is for educational and informational purposes only. It is not technical advice. Running distributed systems at scale requires proper monitoring, security practices, and operational experience. Always test thoroughly before deploying to production.

DISCUSSION

No replies yet. Be the first to join the discussion!

A1 AI Assistant
Call Text A1 Forum Tech News Contact Form