Deploying and Managing Swarm Nodes on the DAppNode Platform: A Complete Guide

You can deploy a production-ready Swarm node on DAppNode by installing the official Swarm DAppNode Package from the rndlabs repository, which provides multi-architecture Docker images and automated configuration through the DAppNode UI or CLI.

This guide walks through deploying and managing Swarm nodes on the DAppNode platform using the ethersphere/awesome-swarm repository as the authoritative index. While Awesome-Swarm serves as the curated gateway that lists the package at line 133 of README.md, the actual deployment artifacts reside in the external rndlabs/dappnodepackage-swarm repository.

Swarm DAppNode Package Architecture

A DAppNode package is a self-contained bundle that abstracts Docker orchestration into a one-click installation. According to the Awesome-Swarm listing, the Swarm package supports multi-platform deployments (x86_64 and arm64) and bundles the Bee client—the official Swarm node implementation—into a production-ready container.

Core Components

The Swarm DAppNode Package consists of four critical elements:

1. Pre-built Docker Image – The Bee client compiled for x86_64 or arm64 architectures (hosted at rndlabs/bee), eliminating manual compilation.
2. docker-compose.yml – Defines service parameters including persistent volumes (mounted at /home/.../bee-data), network ports, and environment variables such as BEE_API_ADDR and BEE_BOOTNODES.
3. dappnode_package.json – The DAppNode manifest describing package metadata, supported architectures, and UI configuration options that appear in the DAppNode store.
4. Optional Web UI – A lightweight interface (often React-based) exposing configuration fields for bootnodes, network selection, and resource limits without requiring file editing.

Network Integration

When deployed, the package exposes the Bee HTTP API on port 1633, enabling access to endpoints like /bzz, /bytes, /feeds, and /health. The node automatically registers its ENR (Ethereum Node Record) with the Swarm network, facilitating peer discovery and content routing without manual firewall configuration, as DAppNode handles TLS termination and secure networking.

Deploying Swarm Nodes on DAppNode

Installation via DAppNode UI

The standard workflow for deploying and managing Swarm nodes on the DAppNode platform uses the graphical interface:

# 1. Navigate to http://my-dappnode.local and open the DAppNode Store

# 2. Search for "Swarm" and select the "Swarm Mainnet" package

# 3. Click "Install" to trigger the following automated steps:

#    - Pulls the Docker image (e.g., rndlabs/bee:latest-amd64)

#    - Creates persistent storage at /home/.../bee-data

#    - Initializes the container with default environment variables

# 4. Verify the deployment:

curl http://my-dappnode.local:1633/health

# Expected output: {"status":"ok"}

# 5. Configure your applications to use:

export BZZ_URL=http://my-dappnode.local:1633

CLI-Based Deployment

For headless servers or automated provisioning, use the DAppNode CLI:

dappnode package install swarm-mainnet

This command pulls the same Docker images and manifests referenced in the Awesome-Swarm catalog but executes without browser interaction, making it suitable for infrastructure-as-code workflows.

Post-Installation Verification

After installation, confirm the node has joined the Swarm mainnet by checking its connectivity:

curl http://my-dappnode.local:1633/health

A response of {"status":"ok"} indicates the container is running. Check the DAppNode "Logs" tab or run docker logs <container> to view peer connection status and chunk synchronization progress.

Managing Your Swarm Node on DAppNode

Configuration Management

You can modify node behavior without SSH access by using the package UI at http://my-dappnode.local/ui/swarm-mainnet. Key adjustable parameters include:

• Bootnodes: Override default peers by setting BEE_BOOTNODES to a custom multi-address (e.g., /dns4/bootnode.ethswarm.org/tcp/1633/p2p/12D3KooW...).
• Network Selection: Switch between mainnet and testnet by changing the BEE_NETWORK environment variable to testnet.
• Resource Allocation: Adjust CPU/memory limits and storage paths through the UI fields mapped to Docker compose constraints.

Upgrades and Maintenance

DAppNode automates image updates while preserving your node's state:

# Via CLI:

dappnode package update swarm-mainnet

# Or via UI: Click "Update" when a new version appears in the Dashboard

The upgrade process pulls newer Docker images from rndlabs/bee and restarts the container while maintaining the persistent volume at /home/.../bee-data, ensuring uploaded content and node identity remain intact.

Data Backup Strategies

Because DAppNode uses standard Docker volumes, backup involves copying the persisted data directory:

# Create a backup of your node's state and uploaded files:

cp -r /home/.../bee-data /external-backup-location/

This safeguards your node's private keys, local chunk cache, and pinned content against hardware failure.

Summary

• Awesome-Swarm (line 133 of README.md) functions as the discovery portal, linking to the external rndlabs/dappnodepackage-swarm repository where the actual deployment logic resides.
• The package bundles Bee client Docker images for x86_64 and arm64, a docker-compose.yml for service definition, and a dappnode_package.json for DAppNode store integration.
• Deploy via the DAppNode Store UI or the dappnode package install CLI command, with automatic exposure of the Bee API on port 1633.
• Manage configuration through environment variables like BEE_BOOTNODES and BEE_NETWORK without editing raw files.
• Upgrade through DAppNode's standard update mechanism while preserving data in persistent volumes.

Frequently Asked Questions

What is the relationship between Awesome-Swarm and the DAppNode package?

Awesome-Swarm is a curated catalog maintained by the Ethersphere organization that indexes Swarm ecosystem projects. According to CONTRIBUTING.md (line 13), projects must be related to Bee or Swarm to be listed, excluding forks. The repository does not host the DAppNode package itself but provides a verified link to the rndlabs/dappnodepackage-swarm repository where the Docker images and deployment manifests are maintained.

How do I switch my Swarm node between mainnet and testnet on DAppNode?

Access the Swarm package UI at http://my-dappnode.local/ui/swarm-mainnet, locate the BEE_NETWORK environment variable field, and change its value from mainnet to testnet. Save the configuration; DAppNode will restart the container with the new network parameter, causing the node to connect to testnet bootnodes and use the appropriate chain configuration.

Can I run a Swarm node on ARM64 architecture using DAppNode?

Yes. The Awesome-Swarm listing explicitly notes that the Swarm DAppNode Package supports multi-platform architectures, including arm64 (ARM) and x86_64 (AMD64). DAppNode automatically pulls the appropriate image tag (e.g., rndlabs/bee:latest-arm64) based on your host hardware during installation.

How do I troubleshoot a failing Swarm node on DAppNode?

First, check the node's health endpoint with curl http://my-dappnode.local:1633/health. If this fails or returns an error, open the DAppNode "Logs" tab for the Swarm package to view docker logs output in real-time. Common issues include insufficient disk space for the /home/.../bee-data volume or connectivity problems to the bootnodes specified in BEE_BOOTNODES. You can also pull the image manually for debugging: docker pull rndlabs/bee:latest-amd64 and test with standalone docker run commands.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}